I was drowning in tabs. Not browser tabs — terminal tabs. I had five AI coding agents open, each one waiting for me to answer a question, approve a change, or just glance at its output. I was the bottleneck, and I was exhausted.
It felt like managing a team of brilliant but clingy interns. Every time I switched to a new agent, the other four would sit idle, their progress frozen until I came back. The whole point of using AI was to save time, but I was spending all my time context-switching.
That’s when I realized: We’ve been thinking about AI agents all wrong. We’re not supposed to be their drivers — we’re supposed to be their herders.
The problem isn’t the AI. The problem is that we’re treating each agent like a manual task, one at a time. We prompt, wait, review, prompt again. It’s serial, it’s slow, and it’s exhausting.
I built a tool called MindFlock to solve this, but the principle is bigger than any single project. The insight is simple: AI agents can work in parallel if you give them their own isolated environments — and Git worktrees make that trivially easy.
Here’s how it works. Instead of one agent working on one branch, you spin up ten agents, each in its own separate worktree. They all have access to the same codebase, but they never step on each other’s toes. They can refactor, test, and commit independently. Meanwhile, you sit back and supervise. You become a conductor, not a typist.
Your job shifts from writing code to making decisions: which agent’s output to merge, which to discard, which to redirect.
But here’s the kicker — most developers aren’t ready for this. They’re still stuck in the ‘prompt and wait’ paradigm. They think one agent is enough. They think they need to micromanage every line of code. That’s a trap.
I’ve seen it firsthand. A colleague of mine would run one agent, watch it write code, then manually review every line. He’d spend hours. Meanwhile, I had five agents working on five different features simultaneously. I’d glance at their pull requests, merge the good ones, and kill the bad ones. I was done in the time it took him to review one.
The future of software engineering isn’t about writing code faster — it’s about managing a fleet of agents that write code for you.
And yes, that requires a new skill set. You need to be comfortable with async workflows, with parallel processes, with letting go of control. You need to trust the tools enough to let them run, but stay sharp enough to catch when they go off the rails.
This is the shift from ‘coder’ to ‘herder.’ And it’s already happening. The developers who embrace it will be the ones who ship features in hours, not days. The ones who resist will be the ones asking why their AI tools are so slow.
So here’s my challenge to you: stop babysitting your AI agents. Start herding them. Give them their own workspace, let them run in parallel, and see what happens when you turn your attention from ‘how do I prompt this?’ to ‘which agent do I promote?’
The best code is the code you never had to write — only the code you decided to keep.
FAQ
Q: Isn't this just a tool? Why not just use a single powerful AI agent?
A: Even the best single agent is limited by serial execution. You prompt, wait, review, repeat. Parallel agents work simultaneously on different tasks, cutting total time dramatically. The bottleneck isn't the AI's intelligence — it's your attention span.
Q: How do I start using this approach without a special tool?
A: You can manually create Git worktrees and run separate agents in each. But it's clunky. Tools like MindFlock automate the orchestration — spawning agents, managing worktrees, and collecting results. The key is to isolate each agent's workspace so they don't conflict.
Q: What if AI agents become so good they don't need human supervision? Won't herding become obsolete?
A: Even autonomous agents need direction. The human role evolves from writing code to setting goals, evaluating outcomes, and making strategic decisions. 'Herding' may become 'managing' — but the human in the loop isn't going away anytime soon.