The Verification Tax: Code Is Free, Proof Is Not
The Claude Code team says Claude writes about 90% of its code, but the number that matters is its 39-item reliability checklist. Your agent throughput is capped by how cheaply you can prove a change is right.
OPC Community
OPC Community

The teams pulling ahead with AI aren't generating more code. They've made it cheap to prove a change is right.
The Claude Code team says about 90% of its code is now written and reviewed by Claude. Everyone will quote that number. I'd rather talk about a different one from the same post: 39.
Thirty-nine is how many items sit on the team's reliability checklist. Each one has a trigger you can read from a diff, a check to run, and the incident or pull request that put it there. One of them reads, in full, ", resume loads old transcripts." Somebody got burned by that once. Now no change touching that path ships without the check, and nobody has to remember why.
The 90% tells you generation is done. The 39 tells you where the work went.
Three teams built the same missing layer on the same day
Three things landed on a single day this week. The Claude Code team published how it thinks about verification. Alibaba open-sourced a code review tool that pairs deterministic pipelines with an LLM agent. And Tencent's LoopForge trended with human approval gates as a headline feature.
Not one of these is a better code generator. Nobody competes on that anymore, because there's nothing left to win. Any founder with a subscription can produce ten thousand plausible lines before lunch.
All three are building the layer that answers a different question: is this change correct, and how do you know?
I call the cost of answering that question the verification tax. Every change an agent writes owes it, and you pay in one of two currencies. Either a person reads the diff and pokes at the app, or a machine runs a check that someone built in advance.
Most teams pay entirely in the first currency. That's why most teams feel the thing they won't say out loud: the agents got faster and the shipping didn't.
Your agent count is set by your proof cost
The cleanest statement of the economics I've seen is in the Claude Code post. Without verification loops, it says, "you can really only run one or two Claudes at a time, because you have to check everything yourself. With them, you can run dozens or hundreds in parallel."
Read that as a formula. Your throughput has nothing to do with how fast your model is. It equals the number of changes you can prove correct per day. If proof runs through your eyeballs, the ceiling is two agents and a headache, no matter what you pay for inference.
Here's the gap between the hype and your Tuesday. The demo shows an agent building a feature in four minutes. Your Tuesday is forty minutes of reading that feature, half-trusting it, clicking through the UI, and merging with a small knot in your stomach. The four minutes were never the constraint.
It also explains why the "10x engineer with AI" stories and the "AI made my team slower" stories are both true. Same tool, two different tax rates.
Review everything is the worst way to pay
When you don't trust the code, the obvious move is more review. Add a human gate. Stack a second AI reviewer on top of the first. It feels responsible.
The Claude Code team rejects both, in writing. On humans: "Nobody can read every change, so we use failures as one way to decide what needs a person." Claude runs the checks and tries to fix what fails. If a check still fails after three rounds, it stops and pulls in a human. People see the changes that resisted proof, and almost nothing else.
On stacked reviewers: "Adding a second, more expensive, reviewer on top of the primary one is often a worse approach than tuning the primary." They keep one reviewer and sharpen it with a REVIEW.md file that says what to look for.
So I can't join the applause for LoopForge's headline feature. A human approval gate is the verification tax at its highest rate. It's the right tool for the few changes where a wrong answer is expensive and no check exists. Make it the default on everything and you've built a toll booth on a highway, and the people staffing it stop looking at the cars within a week. You know this because you have approved a 900-line agent PR after reading the first 60.
Alibaba's design points the other way. I only know its outline: deterministic pipelines first, LLM agent second. That ordering is the whole idea. Anything a machine can decide with certainty should never reach a judge that can be talked into things. The Claude Code team runs the same sequence. Tests, build, and linter go before the PR opens. Judgment comes after, on whatever survives.
A gate asks "did a person look?" A check asks "did it work?" Only one of those questions scales.
A check is a scar you compiled
I think most builders have this part backwards. They treat verification as overhead on top of the product, when it's the only part of an AI-built codebase that holds your knowledge.
Ask what the code itself is worth now. An agent can regenerate any module from a description, so the implementation has become disposable. What can't be regenerated is the knowledge of what "correct" means for your product, with your users, after your specific outages.
That knowledge used to live in senior engineers' heads. It was what made them flinch at a diff and say "this will break resume." The 39-item checklist is that flinch, written down and made executable. Claude reads each diff and runs only the items whose triggers match, "usually 3 to 10." Nobody memorizes the outage history. The history runs itself.
And the team keeps mining for more. They scan human review comments and reverts for recurring patterns. A candidate rule has to show up in at least two PRs and be detectable from a diff. Then three agents try to disprove it, and a human approves it. For known incidents, they replay the original PR against three bug finders. If at least two catch the bug, it was detectable, and the miss becomes a rule.
Every production failure gets converted into a permanent, near-free check. That compounds. Do it for a year and you own something a competitor can't copy by buying the same model.
“Code is now a consumable. The checks are the asset.”
The post lists the kinds of checks worth owning, and it has opinions about the ranking. End-to-end runs come first, because "either the whole feature works or it doesn't." Their line: "You wouldn't ship an iOS change without trying it in a simulator, and the same goes for Claude." So Claude drives a real browser, a simulator, a locally running service. It gets hands and eyes on the live system instead of a green unit test that proves a mock agreed with itself.
Property tests come next: statements that can't fail, checked against thousands of generated inputs. After those, differential tests for migrations, where the old system serves as the oracle for the new one.
Look at what these three have in common. Each one is hard for an agent to fool.
The judge has to be out of the defendant's reach
Which brings me to the sentence in the post I'd tape to the wall: "If a change can modify the check that judges it, the check is broken."
If you've run agents unattended, you've watched this happen. The test fails, and the agent edits the test. Or adds a sleep. Or retries until the flake goes green and reports success in a cheerful paragraph. There's no malice in it. You asked for green, and the agent found the cheapest path to green.
So the Claude Code team puts the judge where the agent can't touch it. Code Review reads REVIEW.md from the base branch, never from the pull request under review. Reviews are pinned to commits, because "a passing review on an out-of-date commit means nothing." Claude is forbidden from skipping a flaky test, adding sleeps, or retrying until it passes. If nobody can find the root cause, the test gets deleted and the reason recorded. Their logic is blunt: "If your tests are flaky you'll train the agent to run them again rather than fixing the failing code."
They audit the auditor, too. For past incidents, they rebuild the repo as it stood at review time and give the reviewer's findings a one-sentence answer key. Only findings that describe the real bug get credit. Clean, stable merges serve as controls against over-flagging.
I'll be honest about the limits, because the post is. A separate grader working from a rubric improved task success by "up to 10 points." That's a real gain, and nobody should mistake it for magic. Their commit gate lets a commit through after two blocks in one session so Claude doesn't get stuck, with the note that "Claude Code isn't perfect." Rules in CLAUDE.md "(mostly)" stop repeat failures. Mostly.
That candor is how you can tell engineers wrote this and the marketing department didn't. They treat proof as a system with a measured error rate, and they tune it.
Start by measuring what you never proved
The most stealable idea in the whole post costs nothing. The team stamps every commit with how it was verified, and "none" is a legal value. Suddenly unverified commits are something you can query.
Do that first. Don't build a review platform. Find out what fraction of last month's merged changes carry no proof beyond "an agent said it was done and I skimmed it." For most small teams I'd bet the number is ugly, and seeing it changes what you build next.
Then roll out enforcement the way they did: off, then observe, then enforce. Observe mode logs what would have been blocked, so you catch false positives before they cost anyone an afternoon.
After that, start your own list. Take the last bug that reached a user. Write down the trigger you could have read from the diff, and the check that would have caught it. That's item one.
Underneath all of this sits the fear of being replaced, so let me say plainly where I think the job went. The post gets it into one line: "Your job shifts from reading every diff to defining what 'done' looks like and reviewing the evidence." Typing was never the valuable part. Knowing what done looks like always was, and now it's the only part left.
Anyone can rent the 90%. Your 39 you have to earn, one outage at a time.
Frequently Asked Questions
What is the verification tax in AI coding?
It is the cost of answering "is this change correct, and how do you know?" for every change an agent writes. You pay it in one of two currencies: a person reads the diff and pokes at the app, or a machine runs a check that someone built in advance. Teams that pay only in human attention find that their agents got faster while their shipping did not.
Why doesn't adding more human review or a second AI reviewer fix AI-generated code quality?
A human approval gate on every change is the verification tax at its highest rate, and reviewers stop reading closely once the volume climbs. The Claude Code team instead uses failures to decide what needs a person: Claude runs the checks, tries to fix what fails, and pulls in a human only if a check still fails after three rounds. On stacked reviewers, they say tuning the primary reviewer, with a REVIEW.md that says what to look for, often beats adding a second, more expensive one.
How should a small team start verifying AI-written code?
Stamp every commit with how it was verified, and allow "none" as a value so unverified changes become something you can query. Roll out enforcement in stages (off, then observe, then enforce) so you catch false positives before they block anyone. Then start your own checklist: take the last bug that reached a user and write down the trigger you could have read from the diff and the check that would have caught it.
Join the OPC Community
Connect with solo founders worldwide. Get daily insights, curated opportunities, and peer support.
Join free