You ask an agent to code an update. It takes about 90 seconds to produce the PR. You then spend the next 90 minutes reading it line-by-line to see if you trust it. You might - whisper it - be shipping code even slower than you were before…
Agent-based development velocity is borrowed time, re-invoiced with interest at review time. The agent writes the PR in seconds, you pay for this speed in the time it takes to decide whether to trust what it has written. This is the Audit Tax.
It’s a deliberate sequel to last Friday’s ‘Stop prompting, start looping’ issue. Verification is one our our six dials and today we’ll be focusing on that.
The bottleneck moved while you were watching the leaderboard
Code generation is effectively solved now. In mid-2026, even the most die-hard holdouts can’t be taken seriously in suggesting that coding agents are sub-optimal coders than human beings in commercial environments. The hard part now is verification.
The old scoreboard, well that just measures the wrong thing: model benchmarks, tokens per second, etc. Not useful metrics anymore. The real workflow measurement is how quickly agent-produced code can get into production.
According to LinearB’s 2026 Software Engineering Benchmarks Report**, AI PRs take 4.6x longer** to get reviewed. This is first and foremost a product of how higher volumes and faster delivery. It’s also first and foremost the biggest blocker to AI Engineering productivity.
Reviewing agent code is harder than reviewing human code
Verification is harder than it looks. You can’t interrogate the agent and trust the answer; the hallucination might be buried in the reasoning. Your old heuristics when reviewing human-written code seem a bit unfit for the task, too:
Agent-written PRs always look clean and self-confident, whether they work or not. Sloppy, partially complete and inadequate documentation no longer happen, so you can’t kick it back to the author on these grounds.
Enforcing small diffs doesn’t work anymore, either (if you try this, 4.6x longer will be a stretch goal, you’ll be drowning in PRs forever).
Reliability of individuals also means nothing anymore. John the old hand who always ships clean code and whose output requires a cursory review? John’s gone. There’s just Claude now.
One last thing - don’t forget that you’re contributing to The Sloppening when you push slop code to the DB.
Stop paying the tax by hand. Build the verification layer.
Get your cheap, deterministic gates done first: typecheck, tests, lints, builds. You have them already, they’re virtually free and fast and they catch stupid mistakes. Anthropic refers to these as Code-based graders.
Then you need a review subagent. In Anthropic world, these are Model-based graders. Check the diff against the stated intent, not just whether it builds/runs.
The next phase is human-in-the-loop: a person’s eyes on anything that survives the deterministic and agent-review gate. Machines jump across the first few hurdles and then the human lets the output hit prod. The faster among you might already have guessed that Anthropic calls these Human graders.
Evals make verification repeatable, not vibes
Anthropic recommend starting early on Evals, and so do I. Start recording cases where the Agent has not met requirements and when you’ve got ~20, it’s time to start building your Evals.
Add your deterministic checks and an LLM-as-judge for the fuzzy intent. Wire them on triggers (not necessarily in your CI/CD - more on this in a minute) to ensure you don’t manually need to kick them off.
There’s a really in-depth blog here that goes into the weeds on methodology but is somewhat lighter on the technical implementation. Take that as a sign of how much this step in the agentic loop is in its infancy (and the blog post is also from way back in January 2026).
**Action steps (do this week)**
Measure your tax: time-to-generate a PR versus time-to-merge it. The gap is the ‘invoice’.
Add one mandatory CI gate the agent cannot merge past (start with tests or typecheck).
Stand up a 20-case eval from last month's actual agent failures.
Add a "review" pass that checks diffs against intent before they reach you.
Re-measure the gap. Watch the tax drop.
The toolkit: this week we ship a verification starter #
I’m cheating mentioning this now. We’ll be shipping this on Thursday of this week, 2nd July 2026.
Why this matters #
Remember we’re talking about the reframing of the dev career ladder. We started with Context Engineering (2024), now we’re at Loop Engineering (2026). If you’ve been following along, this makes you one of the top players in software development and sets you up very well for the future.
Whoever owns the verification owns the bottleneck, and whoever owns the bottleneck owns the leverage. Code generation is solved and the tax is rigorous evaluation.
Pay the tax on purpose, or pay it by accident. See you next Thursday.