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

For thirty years the scarce resource in software was writing code, so we optimized everything around typing speed. AI made writing nearly free — and the constraint quietly relocated to verification: reading, trusting, and accepting output. Most teams never restructured. They're pouring more water into a funnel whose neck is now review, then wondering why 'faster' didn't feel faster. Velocity metrics lie because they measure the half that's no longer the bottleneck.

- **Author:** Fedor Chishchin
- **Published:** 2026-07-01
- **Tags:** methodology, ai-native
- **Source:** https://fedorthinks.com/blog/the-bottleneck-moved-to-verification

---

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](https://www.aviator.co/blog/the-ai-code-verification-bottleneck-why-faster-code-generation-means-slower-reviews/)
even as individual task completion rises. Most developers [don't fully trust AI output's correctness,
yet a large share commit without always verifying](https://byteiota.com/ai-code-verification-bottleneck-96-dont-trust-output/)
— which is just the bottleneck bursting downstream as bugs instead of being paid at review. As
[DevOps.com put it](https://devops.com/the-bottleneck-isnt-coding-anymore-its-verification/): "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](/blog/evals-or-it-didnt-ship),
  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](/blog/workslop-is-a-tax) 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.**