The Week I Stopped Coding: Orchestrating an Army of AI Agents

Last week, a profound shift occurred in my work: I stopped coding. Let me be clear—I didn’t stop building software, but the very act of coding itself ceased to be my primary engagement. This distinction, I quickly realized, matters more than you might think, signaling a fundamental evolution in how we build and, crucially, in the very nature of technical leadership and architecture. I found myself back in a familiar role: a director overseeing numerous teams, or 'pods' (a term I recall from my time at EY), each with a cadre of workers underneath.

The Setup: From Developer to Orchestrator

A few weeks ago, curiosity led me to experiment with AI agent frameworks—complex, autonomous software programs designed to perform tasks, often by interacting with large language models (LLMs) and other tools. My journey began with Claude Code, a CLI tool designed to "vibe" code and directly control your computer (https://en.wikipedia.org/wiki/Claude_(language_model)#Claude_Code)). Building upon this, I integrated claude-flow, an npm package that extends Claude Code's capabilities with a comprehensive tool suite to manage context, memory, agents, swarms (collections of these agents working collaboratively), and direction files. Soon after, I had added plugins, pulled down skillsets, integrated MCP servers and CLIs, completely handing over control of a localized environment to my growing swarm.

It no longer had just control of a single repository, but an entire development ecosystem. Soon, this wasn't just about code assistance. The agents were iterating, improving, refactoring, and crafting next steps—all while continuously engaging, running, and deploying. What began as a simple exploration rapidly evolved into a fundamentally different way of building software. Within days, I had 10 agents running simultaneously across different repos and projects, each humming away at their assigned tasks.

I created a central repository that held context across my 8+ active projects. I started separating concerns, pushing context down as much as possible to keep each agent focused and effective. I added Linear for project management. I set up monitoring and dashboards to track progress across this distributed system.

Déjà Vu: This Is Enterprise Digital Transformation

The true scope of this shift became glaringly clear, and with it, a profound realization: orchestrating these AI agents felt exactly like managing enterprise digital transformation. The 'workers' were now swarms of threads making requests to LLMs, stepping into roles traditionally filled by individuals in a major corporation. The way I was working felt almost eerily familiar. This wasn't just building; it was a microcosm of the massive project kickoffs and sprawling digital transformations I managed during my time consulting at Zilker Technology and Ernst & Young. These were the architecture and design sessions that kicked off digital transformation projects that rippled across entire organizations, consuming months of meticulous planning.

I thought back to those engagements: the careful distribution of work across multiple teams, the constant iteration and refinement, the Proofs of Concept (PoCs) we’d run before committing to full implementation. The key difference? Those projects involved dozens or hundreds of human resources: architects, managers, product owners, developers, QA testers, DevOps engineers, infrastructure specialists, directors, and executive leaders.

Now, all of that was being directed by me and my agents.

AI Orchestration: A New Organizational Blueprint - The Organizational Mirror

The organizational structure mirrored itself almost eerily. Instead of hundreds of people underneath me, I had hundreds of agent instances. Groups of 3-5 agents with a “leader” agent. Those leaders reported to higher-level coordination agents, which in turn interacted directly with me.

But here’s where it gets interesting: instead of scheduling meetings, sending calendar invites, and waiting for responses, I was answering questions and providing context through Linear tickets. I’d respond, hand it back down the chain, and watch the work continue to spin.

The Reality Check: Not Perfect, But Familiar

Did things go off track sometimes? Absolutely. My agents occasionally veered into unexpected territory or misinterpreted context, leading to some hairy moments.

But here’s the thing: those multi-million dollar contracts with tens or hundreds of human resources? They went off track too. Miscommunications happened. Requirements got misunderstood. Technical debt accumulated. The difference wasn’t in the perfection; it was in the speed of correction.

When an agent team veered off course, I could course-correct in minutes. In contrast, a human team hitting a blocker often meant scheduling a meeting days out, spending an hour discussing it, and then waiting for the implementation cycle to restart.

The Speed Factor: Hours Instead of Months

I’m now accelerating through the entire software development lifecycle at a pace that feels almost surreal. What once required months now unfolds in hours.

To illustrate this velocity, in a single day, my agent army now delivers:

• RBAC implementation
• Complete DevOps pipelines
• CI/CD automation
• Terraform infrastructure as code
• API development and versioning
• Database schema migrations
• UI updates and refinements

The workflow looks like this: I receive mockups and wireframes first. Then architecture reports land with decision points clearly outlined. I review, provide feedback, make calls on the architectural decisions, and respond—all in minutes rather than weeks.

The traditional back-and-forth that consumed entire sprint cycles now happens in near real-time. This hyper-accelerated pace fundamentally redefines the limits of what a single technical leader can achieve.

The Full Stack Reality

What’s particularly striking is the breadth of work happening simultaneously. I’m not context-switching between tasks the way a solo developer traditionally would. I’m orchestrating parallel workstreams across the entire stack.

One agent cluster is refactoring the authentication system while another implements new API endpoints. A third group is updating the UI components while a fourth handles database optimization. DevOps agents are spinning up new environments and configuring monitoring.

Crucially, I am not removed from the technical decisions. I still understand the underlying code. I still diagnose complex issues, deep dive into performance problems, and call out architectural flaws. However, my role has fundamentally shifted from primary implementer to architect and director. This parallel orchestration across the entire stack allows for unprecedented velocity and breadth of development under unified strategic direction.

The Emotional Complexity

Beyond the technical marvel, this unprecedented acceleration brought with it a complex, even conflicting, emotional landscape. The world is changing at an unprecedented rate, and I’m watching it happen from the inside.

This experience is amazing, eye-opening, disheartening, and scary. All at once.

I’m excited about what’s possible. The acceleration is intoxicating. Building things that would have taken a team months to deliver, and seeing them come together in days—there’s a rush to that.

But alongside the excitement, a profound shift is underway. I still remember the deep satisfaction of crafting elegant functions, of refactoring a particularly gnarly piece of logic, of naming variables just right. These cherished individual lines of code are now fading from my day-to-day reality. This shift isn't just personal; it represents a seismic change for many developers and technical professionals.

I still appreciate good code. I can still spot a performance issue or an architectural misstep. But my relationship to the code itself has changed. It’s no longer my primary medium of expression. This personal transformation, I realized, wasn't just about me; it signaled a broader, profound inflection point for software development.

What This Means for the Industry: Evolving Technical Leadership

This personal evolution signals a broader inflection point for software development. The role of the technical leader is rapidly evolving from the “best coder in the room” to the “best orchestrator of technical work.”

Far from becoming irrelevant, my 20+ years of experience has become more valuable. The architectural knowledge, the understanding of how systems fit together, the ability to spot risks and trade-offs—all of that matters more than ever.

What changed is the leverage. Instead of that knowledge bottlenecking on my ability to type code, it now flows through an army of agents that can execute in parallel.

For technical leaders, this is a paradigm shift. The skills that matter are:

• Architectural vision and systems thinking
• Context management and information architecture
• Project orchestration and work breakdown
• Quality assessment and risk identification
• Strategic decision-making under uncertainty

The skills that matter less:

• Raw coding speed
• Memorizing syntax
• Implementing boilerplate patterns
• Repetitive debugging

The Path Forward

I don’t know exactly where this leads. I suspect my experience is a preview of what many technical leaders will face in the next 12-24 months.

What I do know is that software development as a discipline isn’t going away; it’s transforming. The leaders who can adapt, who can learn to work with AI agents as force multipliers rather than replacements, who can maintain their technical judgment while delegating implementation—they’re going to thrive.

For me, this week marked a transition. From developer to orchestrator. From coder to conductor. The symphony is larger now, and the pace is faster, but the music still needs someone who understands what it should sound like.

This setup might not be permanent—I might even wipe a whole repo—but the next logical step, however, involves integrating Kubernetes—imagine pods spinning up not just to execute tasks, but to further self-optimize, maintain, and evaluate the entire agent system, ensuring dynamic scaling and resilience. This is the frontier of truly autonomous orchestration. We’ll see where this goes.

For technical leaders navigating this profound shift, I urge you to reach out and compare notes on this brave new world we’re building. What challenges and opportunities are you encountering as you consider or implement AI agent orchestration in your own organizations? Share your insights, contact me, or comment below—let's discuss this future together.

Mathew Dostal is a fractional CTO and technical leader with 20+ years of experience in enterprise software development, cloud architecture, and digital transformation. Learn more about his work at mdostal.com.