Writing code is no longer the bottleneck.

Verification is. Teams generate more AI code than anyone can read.

• 85% of the 1,528 developers and technology buyers in GitLab's Harris Poll survey say the bottleneck has moved from writing code to reviewing and validating it.
• 42% of committed code is now AI-generated, heading for an expected 65% by 2027, per Sonar's State of Code 2026 survey of 1,100+ developers.
• 96% of those developers don't fully trust that AI-generated code is functionally correct, and only 48% always check it before committing.

My read: another round of skepticism will not clear the queue. You need a standing rule about which changes may ship unread.

Take Uncle Bob Martin, he doesn't read the code his agents write.

He can defend that, because a gauntlet of unit tests, Gherkin acceptance tests, QA procedures, mutation runs and quality metrics can fail the code without him.

The rule underneath his setup transfers even if you never run his full Gherkin stack: an agent earns only as much autonomy as you can verify cheaply and reliably, scaled to what breaks when it's wrong.

What follows is that rule, five settings for agent PRs, the red-list that never earns Full auto, and what to do this week.

Why review is the bottleneck

Review is the bottleneck because generation got cheap and verification didn't.

GitLab's 2026 AI Accountability research reports 79% saying individual productivity improved while overall delivery has not accelerated at the same pace.

GitLab calls that the AI Paradox. Sonar adds that 38% say reviewing AI-generated code takes more effort than reviewing a colleague's.

Both vendors sell into this problem, Sonar in code quality and GitLab in DevSecOps.

Their numbers still match what engineers describe in public, and trustworthy verification is now the scarce resource that every autonomy decision spends.

What Bob Martin's method includes

Bob Martin's stack is unit tests, Gherkin tests, QA procedures, quality metrics, mutation testing and coverage.

This claim is that code surviving all of it has earned his confidence without his eyes, having "run the gauntlet of all of my constraints and tests."

Retellings drop the management loop around that stack.

Agents write the unit tests and he doesn't read them. The acceptance tests and QA procedures he reads or spot-checks by how critical the project is.

He watches the agents execute, interrogates them about internal structure, and manually tests the output at the end of every short increment.

In his words: "I watch them like a hawk. I never trust anything they do. I trust the tools that I have given them, but do not trust them to use those tools."

He pays for all of that with the speed itself.

Agents are "maybe 20 times" faster, his estimate rather than a measurement, and the surplus goes into mutation testing (injecting artificial bugs to ensure the test suite catches them) and adding property, performance and jitter tests.

How back pressure sets autonomy

Addy Osmani states the bound as a rule: "you can only hand a loop as much autonomy as you can cheaply and reliably verify, and not one inch more."