The bottleneck moved. You're still optimizing the old one.

Every system has one constraint that sets its pace. For thirty years in software, that constraint was producing code — writing it, typing it, getting it out of your head and into the editor. So we built our entire craft around that: faster typing, better autocomplete, snippets, frameworks, more throughput. Then AI made producing code nearly free — and the bottleneck moved. Almost nobody moved with it.

The neck of the funnel is now review

When generation is cheap, the thing that actually gates delivery is verification: reading the output, understanding it, deciding whether to trust it, and taking responsibility for it. And the data shows exactly this shift. Code review time is reportedly up around 91% after AI adoption even as individual task completion rises. Most developers don't fully trust AI output's correctness, yet a large share commit without always verifying — which is just the bottleneck bursting downstream as bugs instead of being paid at review. As DevOps.com put it: "the bottleneck isn't coding anymore. It's verification."

Making the un-constrained step faster doesn't speed up the system. It just piles inventory in front of the constraint.

This is Theory of Constraints 101, and AI walked us straight into it. Optimizing code generation now — more agents, faster models, more output — is optimizing the step that isn't the bottleneck. All that extra generated code doesn't ship faster; it queues up in front of a human who now has more to read, trust, and own than ever.

Why your velocity metrics are lying

Here's the trap: the metrics we inherited all measure the old constraint. Lines shipped, tasks completed, PRs opened, "time to first draft" — they all light up green when generation gets faster, which is exactly the half that's no longer the problem. Meanwhile the real question — how fast can a human confidently accept this? — doesn't show up on any dashboard, because it's not a throughput number. It's a trust number. And trust doesn't scale by adding compute.

What optimizing the real bottleneck looks like

• Make output easy to verify, not just easy to produce. Smaller diffs, explained changes, reproducible steps. A change you can review in two minutes beats one that's twice as big and takes twenty.
• Invest in the accept step. Tests, types, evals that gate merges, deterministic checks — anything that lets a human trust output without re-deriving it by hand. That's where throughput actually lives now.
• Measure time-to-confident-accept. Not how fast you generated, but how long until someone could own it. If that number isn't improving, your "faster" is an illusion.
• Protect reviewer attention like the scarce resource it is. Drowning your best people in plausible AI output isn't leverage — it's moving the work downstream onto the one step you can't parallelize away.

The bottom line

AI didn't remove the bottleneck; it relocated it — from writing to verifying — and left our habits and metrics pointed at the empty station. Generating more, faster, just deepens the pile in front of the step that actually sets your pace.

Stop optimizing the keyboard. The constraint is trust now — make output cheap to verify, and measure how fast a human can confidently say yes.