I have never really considered myself a traditional software developer. At best, I have always been a scripter.
My primary domain has always been infrastructure, network engineering, cybersecurity, and technical operations. Whenever I wrote code, it was out of operational necessity — putting together Bash scripts, Batch files, or custom automation tools to glue infrastructure together, manage server queues, or automate security checks. The architecture was often dubious, the standards were pragmatic rather than clean, and if a script solved the immediate problem, it went straight into production.
When ChatGPT first dropped in late 2022, I jumped straight in. Looking back through my local project timestamps, by the first week of January 2023 I was already throwing trading bot ideas and Python algorithms at it, trying to push what early models could generate.
Over the last few years, that workflow has shifted dramatically — moving from painful manual slicing to an almost effortless autonomous development stack.
The progression of AI-assisted development: from copy-pasting snippets in web chats to 100% autonomous agentic execution in 2026
The Evolution of My AI Workflow (2022 – 2026)
Looking back at projects across my drive, the transition happened in four distinct stages:
┌─────────────────────────────────────────────────────────────────────────────────────────────┐
│ The AI Development Progression │
├───────────────────────────────┬───────────────────────────────┬─────────────────────────────┤
│ 2022–2023: Web Chatboxes (20%)│ 2023–2024: Repo Packagers(50%)│ 2025–2026: Autonomous (100%)│
│ • Typing "continue..." │ • Custom .bat / .sh packagers │ • Multi-agent orchestration │
│ • Splicing Part 1 & Part 2 │ • Bundling code into .txt │ • Security & commit audits │
│ • Python trading bot scripts │ • Managing tight token limits │ • Rapid GitLab expansion │
└───────────────────────────────┴───────────────────────────────┴─────────────────────────────┘1. 2022 – 2023: The Web Chatbox Era & Typing “Continue…” (~20% Assistance)
In the early days of GPT-3.5 and the first Claude release, AI was essentially an interactive Stack Overflow with severe output constraints. I used it for small, isolated tasks — helping me remember awkward regex syntax, writing a quick PowerShell one-liner, or generating boilerplate for my early Python trading scripts.
Anyone who coded in that era remembers the friction: asking for a multi-function script, watching the model abruptly stop mid-file because it hit the output token limit, and frantically typing "continue" over and over. You would end up with code split across Part 1, Part 2, and Part 3, leaving you to manually copy, paste, and stitch broken code blocks together in your text editor without introducing indent errors. At this stage, AI was doing maybe 20% of the heavy lifting, and I was still writing the other 80%.
The classic 2022 workflow: code truncation, typing “continue…”, and manually splicing Part 1 and Part 2 together
2. 2023 – 2024: The Repo Packager Era (~50% Assistance)
As my projects grew into multi-file architectures, copy-pasting single functions into web chatboxes broke down because the model lacked overall codebase context.
To work around this, I wrote custom repository packager scripts (like my combine_markdown.py tool). These scripts crawled my project directories, stripped out binaries and dependency folders, and concatenated the entire codebase into a single structured .txt file ready to upload into a fresh AI session. Because context windows were still tight, I spent significant time manually splitting modules and selecting which files to package so I wouldn’t overflow the token limit. At this stage, AI was taking over roughly 50% of the workload.
3. 2024 – 2025: Agentic Tooling & CLI Integration (~80% Assistance)
The shift from passive browser chatboxes to active agent tooling changed the entire paradigm. Instead of manually packaging text files, AI tools gained direct access to inspect local repositories, run terminal commands, execute compilers, and fix build errors iteratively in the background. AI went from being an occasional assistant to handling 80% of my development workload.
4. 2025 – 2026: 100% Autonomous Code Generation & Multi-Agent Audits
Today in 2026, AI handles virtually 100% of my raw code generation, test scaffolding, and refactoring work.
Beyond just writing features, I now deploy multiple specialized AI agents running concurrently — paired with a custom agent orchestration harness — to handle the full software lifecycle. Different agents autonomously write code, audit Git commit diffs, perform static security and vulnerability scans on the repository, and resolve build errors before merging. My role has shifted entirely from writing syntax to acting as a system architect, security reviewer, and operator — defining high-level specs, evaluating operational trade-offs, and steering agent swarms.
The modern 2026 agentic loop: from architecture intent to automated tool calling, testing, and GitLab deployment
What This Shift Means for Technical Operators & SREs
As someone coming from an infrastructure, networking, and security background, the biggest advantage of modern agentic AI isn’t just generating boilerplate front-ends — it is supercharging operational automation, data reporting pipelines, and security auditing.
A great example was when I tackled an infrastructure overhaul: AI helped analyze complex dependency chains and map out the exact multi-major version upgrade path for my self-hosted GitLab server on Debian, navigating PostgreSQL major version bumps, background queue drains, and breaking schema changes without a hitch.
Tasks that previously sat in my backlog for months — custom monitoring dashboards, automated operational reporting daemons, security scan aggregators, and self-healing infrastructure scripts — can now be architected, tested, and verified in a single afternoon. My private GitLab server and Proxmox clusters are running automated services that I simply wouldn’t have had the time or patience to write manually line-by-line.
For technical operators and Site Reliability Engineers who aren’t traditional application developers, modern agentic AI is the ultimate multiplier. It translates your systems instincts, security domain knowledge, and infrastructure architecture directly into production-ready software faster than ever before.
If you are interested in some of the older automation scripts and tools I built before modern AI existed, check out my retrospective on from batch loops to Go binaries: a scripter’s language evolution, my deep-dive into automating IRC network security in the 2000s, or my guide on creating simple background systemd service units on Linux.