The AI Bottleneck Moved: Why Verification, Not Generation, Now Caps Your Leverage

Here is the most useful thing anyone has measured about AI at work, and almost nobody has internalised it. In a randomised controlled trial last year, experienced developers were given AI coding tools on their own real repositories. They expected to be about 24% faster. Afterwards, they estimated they had been about 20% faster. The measured result was a 19% slowdown — and they never noticed.

The instinct is to read that as a story about the tools not being good enough yet. It isn't. It's a story about where the work went. The AI wrote plenty of code, fast. But the developers still had to read it, understand it, find the parts that were subtly wrong, and fix them — and that loop cost more than writing the code themselves would have. The generation got cheaper. The verification didn't. And the verification was always the expensive part.

The bottleneck moved, and it moved to a place that doesn't compress

For most of computing history, producing the artefact was the slow, skilled, expensive step. Writing the code, drafting the memo, building the model — that was the work. Checking it was the cheap afterthought. AI has inverted that. Producing a plausible first draft of almost anything now costs seconds. What costs time — what has always cost time, and still does — is being sure the thing is right enough to ship.

So the bottleneck to how much value you can safely get out of AI is no longer generation. It's verification. For an engineer, that shows up with a specific name: the review. You can ask an AI for ten pull requests. You cannot meaningfully review ten pull requests in the time you used to review two. The machine's output piles up at the one desk it can't sit at — yours.

And review is uniquely resistant to being sped up:

• It doesn't scale like generation. Generation went from hours to seconds. Reading-and-understanding is still bounded by how fast a human can reason about a system. You can 10× the output; you cannot 10× the comprehension.
• AI output is harder to review, not easier. A junior engineer's mistake usually looks like a mistake. An AI's mistake looks like correct code — it is plausible-but-wrong by construction, optimised to read as right. And there is far more of it. More surface, better camouflage.
• Polish lowers your guard exactly when it should raise it. When a draft arrives looking finished, people question it less — they clarify the goal and tweak the format, and check the facts and the reasoning less. The better the output looks, the worse the review gets. That's the failure mode a fast-moving team never sees coming.
• Accountability can't be delegated. You can hand the AI the writing. You cannot hand it the responsibility for what ships. The human verification step is irreducible for anything consequential — which means the bottleneck is structural, not temporary.

This isn't just an argument anymore; it's measurable. Faros AI, across more than 10,000 developers, found that as AI generation took off, pull-request volume rose 98% while review time rose 91% — the work didn't vanish, it moved from the keyboard to the review queue. A 2025 study clocked senior engineers spending 4.3 minutes on an AI-generated change against 1.2 on a human-written one, and CodeRabbit found AI-written code surfaces 1.7× more issues to catch. Generation got faster and reviewing got slower and heavier at the same time. That is the bottleneck, in numbers — and it's why only about a quarter of senior engineers say they'd ship AI-generated code without a human review.

It isn't just engineers

Call it "the review" for engineers because that's where it's most visible. But the same bottleneck sits under every function, wearing a different name. For an investor, it's the diligence call — AI can summarise a hundred decks, but someone still has to verify the one number the decision turns on. For a writer, it's the fact-check and the taste. For a doctor, it's the clinical judgment and the liability. In every case the bottleneck is the same shape: the verification of consequential output by an accountable human — the one step you can't safely hand to the machine, and the one that doesn't get cheaper as the machine gets better.

The bottleneck and the safety floor are the same thing

This is the part worth sitting with, because it changes how you should think about AI value entirely. I score companies for a living, and I judge a team's AI use the way I'd judge any investment: on two axes, Return and Risk. Return is what the AI actually makes you. Risk is what it could lose you — and the core of that risk is precisely the absence of verification: the unreviewed output that shipped as fact, the irreversible action nobody checked.

Put those two things next to each other and something clicks: the verification step is the Risk floor, and it's also the leverage bottleneck. They are not two separate concerns to be balanced. They are the same constraint seen from two sides. Which means the fastest-looking teams — the ones generating enormous output with no review step — haven't beaten the bottleneck. They've just stopped measuring it. That's not leverage. It's exposure with good production values, running at speed until the one output that mattered goes wrong. Return that never cleared the review was never Return.

So how do you actually get leverage?

Not by generating more. Generating more just makes the queue at the review desk longer. You get leverage by attacking verification directly — making the checking cheaper, faster, or unnecessary. Four moves, in rough order of power:

1. Produce verifiable output, not just more of it. This is the highest-leverage habit and the least practised. Ask the AI for the code and the tests that prove it. The claim and the citation. The number and where it came from. The decision and the trail behind it. That shifts the human review from "read every line and reason about all of it" to "check that the proof holds" — a far cheaper operation. The goal of generation should be verifiability, not volume.

2. Move the verification into the machine — build the check once. The best engineers aren't reviewing more AI output; they're building the thing that reviews it: the test suite, the type system, the eval, the automated gate. You review the verifier once, and then it checks every future output for free. This is how you break the bottleneck instead of grinding against it — you automate the step that doesn't compress, rather than doing it by hand forever.

3. Triage review by blast radius. Not everything deserves the same scrutiny. A reversible, low-stakes action can run and be sampled after the fact. An irreversible, high-stakes one — money, production data, anything you can't take back — gets a human gate before it happens. Spending equal review on a typo fix and a payment is how the review desk drowns. Match the depth of the check to the size of the mistake.

4. Raise the reviewer's skill. The person who can spot the plausible-but-wrong output in ten seconds, and knows exactly which artefact would prove it right, has more real throughput than someone generating twice as fast with no eye for the flaw. Reviewing well is a skill, and it's now the scarce one. In a world where anyone can generate, judgment is the moat.

The one line to keep

AI didn't remove the work. It moved it — from writing to reviewing. The teams that win the next few years won't be the ones generating the most; they'll be the ones who can verify the most, per hour of scarce human judgment. Leverage now belongs to whoever can check fastest, not whoever can produce fastest. Build for that, and the bottleneck becomes your advantage instead of your ceiling.

Frequently Asked Questions

Why does AI make some experienced engineers slower?

Because for someone who already knows a codebase well, the time saved on writing code is smaller than the time spent reading, understanding, and correcting the AI's plausible-but-wrong output. In METR's 2025 randomised trial, experienced developers were measured 19% slower with AI on their own repositories, even though they believed they were about 20% faster. The generation got cheaper; the verification — the review — did not, and it was the expensive step.

What is the real bottleneck to AI leverage?

Verification, not generation. AI drove the cost of producing work toward zero but left the cost of checking that work roughly unchanged. Since you can't safely ship what you haven't verified, the human verification of consequential output — for engineers, the code review — becomes the binding constraint. It doesn't compress the way generation does, which is why simply generating more doesn't produce proportional leverage.

How do you get more leverage from AI if verification is the bottleneck?

By attacking verification rather than generation: produce output that is cheap to verify (code with tests, claims with citations, numbers with provenance); automate the check by building the verifier once (tests, evals, gates) instead of reviewing by hand; triage review by blast radius so scrutiny matches stakes; and raise the reviewer's skill, since spotting the flawed output fast is now the scarce capability.