There’s a quiet assumption under almost every “AI for engineering” rollout: that the pipeline is fine, and the agents just plug into it. Same Git repo, same pull-request review, same branch protection, same CI gates — now with more contributors. But every one of those was designed around a single scarce resource: human coding time. Review every line, protect the branch, gate the merge, so a handful of people committing a few times a day can keep the system coherent. It was the right design. For humans.
Point a swarm of agents at that same pipeline and it doesn’t get faster — it gets a new bottleneck. The agents move at machine speed and then queue behind a human-speed process. You bought the speed and throttled it on the way out the door.
The worktree didn’t fix it — it moved the bottleneck
The sophisticated teams already saw the first problem. Agents clobbering each other in one working tree is chaos, so they gave each agent its own Git worktree. Good instinct. Isolation solved. But look at what happens next: all those branches come home to the same place they always did — a human, resolving the merge by hand. And not just the merge. After a hand-merge, someone gets to chase the bugs the merge itself introduced, which is a whole second wave of work nobody scheduled.
There’s an old idea from manufacturing that fits exactly: a system can only move as fast as its slowest part. Ten agents running flat out and one person merging by hand — the person is the constraint. Per-agent worktrees didn’t remove the bottleneck. They relocated it to the merge desk.
Code got cheap. Coherence got scarce.
Here’s the first-principles part. The old pipeline optimized human coding time because that was the expensive thing. Agents changed the equation — code is cheap now, written and thrown away and rewritten before lunch. What’s scarce now is coherence and intent: keeping the system consistent while many hands move fast, and remembering *why* each choice was made once the agent that made it has reset ten times.
If the scarce resource changed, the pipeline should too. You don’t retrofit the old one — you rebuild around the new constraint. That means letting the machine coordinate at machine speed, and keeping the human doing the thing only a human should: steering.
Take the human off the merge path
That’s what an AI-mediated source-control system does. Every agent gets its own line of work automatically, and overlap is settled before code exists — and again at merge, where compatible edits are combined anywhere in a file, including the same lines, and anything genuinely in tension is routed back to the right agent to rework. Nothing is silently overwritten, and no human is standing at the merge desk.
It shows up in the bill. We build the same product two ways — an agent team with CatWrangler and one without — and it keeps coming out cheaper. On our strongest run so far it came in about 37% cheaper, mostly from the stomping and the second-wave rework that never happened, plus agents spending less time reading and re-deriving code because the reasoning was already captured. One build, not a guaranteed average — but it keeps landing the same way.
You steer. The machine merges.
Going all-in on AI doesn’t mean taking your hands off the wheel. Authority stays with the humans — agents act at every decision point, and you direct. And because every decision is captured with its reasoning, you get a living audit trail for free: why the system is the way it is, queryable in plain English, instead of locked in one person’s head or lost to an agent’s reset context.
If you run engineering and you’ve been trying to bolt AI onto the pipeline you inherited, that’s the thing worth reconsidering. Not the agents. The pipeline. There’s a fuller walk-through of the argument on the engineering-leaders page — including what the two pipelines actually look like side by side.