The Orchestration Gap: why AI made software delivery harder, not easier

For most of software's history, the constraint on shipping was writing the code. Everything in our tooling — IDEs, autocomplete, code review, CI — evolved to make that one act faster and safer. Then AI coding agents removed the constraint almost overnight. A single engineer with Cursor or Claude Code can now generate more working change in an afternoon than a team used to produce in a sprint.

The natural assumption is that delivery therefore got easier. In practice, for teams past a certain size, it got harder. Not because the code is worse — often it's fine — but because the constraint moved somewhere we haven't built tools for.

As code generation approaches zero cost, the bottleneck in software delivery moves entirely to coordination, governance, and memory.

— The Orchestration Gap

What is the Orchestration Gap?

The Orchestration Gap is the widening distance between how fast AI can generate code and how slowly organizations can plan, govern, remember, and verify it. Generation capacity is compounding — better models, more agents, more autonomy every quarter. Human coordination capacity is roughly fixed. Every improvement in generation widens the gap unless you add orchestration to match.

You can feel the gap even if you don't have a name for it. It shows up as a specific cluster of symptoms:

• Agent-written code that ships and works, but that no human on the team fully understands.
• Specifications that quietly stop matching the implementation — spec drift — because agents change code without updating intent.
• Review queues that can't keep pace, so review becomes a rubber stamp or a bottleneck.
• No clear answer to 'what will this change affect?' — blast radius is invisible until something breaks.
• Institutional memory that evaporates faster than ever, because the 'author' of much of the code was an agent that kept no context.

Velocity goes up and confidence goes down at the same time. That combination is the signature of the Orchestration Gap.

Why faster agents make it worse

It's tempting to think better models will close the gap. They won't — they widen it. A more capable agent produces more change, more autonomously, which is exactly the thing outrunning your ability to coordinate and remember. The gap is not a model-quality problem; it's a systems problem. You don't solve it with a smarter agent any more than you solve traffic with faster cars.

What closing the gap actually requires

Closing the Orchestration Gap means adding the layer that AI generation skipped over. Concretely, four capabilities:

1. Capture intent as structured, machine-usable artifacts — not vague prompts, but requirements and blueprints agents can execute against.
2. Orchestrate agents from that intent — dispatch work, supply full context, and observe results centrally instead of per-developer.
3. Govern every change — approval gates, blast-radius analysis, and drift detection so velocity never outruns control.
4. Remember everything — an engineering memory graph so context is self-serve for humans and agents, and nothing is lost when people or agents move on.

The uncomfortable implication

If the bottleneck has moved, then most of the tooling investment of the last two years — faster agents, better autocomplete — is optimizing the part that's already solved. The teams that pull ahead won't be the ones with the best agent. They'll be the ones who built the orchestration, governance, and memory around it first. The gap is the opportunity.