AI-written code costs 2.1× more to review than to generate

I hate reviewing code written by agents. Nobody wrote it, nobody cares about it, and when I leave feedback the author cheerfully tells me I am absolutely right. Then it generates another pile of code for me to read.

So I worked out what this activity costs.

By my estimate, it costs $0.24 for a human to review one changed line of code and $0.11 in model spend to produce one benchmark-accepted changed line.

Under those assumptions, reviewing AI-written code costs about 2.1 times as much as generating it.

The calculation

In 2006, SmartBear published a study of code review at Cisco. It covered more than 2,500 reviews and 3.2 million lines of code. The study found that reviewers caught the most defects below 300 lines per hour, while rates below 500 lines per hour were still considered good. I used 400 lines per hour as a workable midpoint.

The US Bureau of Labor Statistics reports a median software-developer wage of $65.38 per hour for May 2025. Its March 2026 employer-compensation data says benefits represented 30.8% of compensation for private-industry professional and related occupations.

Treating $65.38 as the wage component gives:

loaded hourly compensation = $65.38 / (1 - 0.308)  = $94.48
review cost per changed LOC = $94.48 / 400         = $0.236

Rounded to the nearest cent, that is $0.24 per reviewed line.

For generation, I used OpenHands’ public GPT-5.5 SWE-bench Verified run from May 2026. It attempted all 500 benchmark tasks using OpenHands v1.18.1 at high reasoning effort and resolved 391 of them.

I counted additions plus deletions in each final patch, excluding the diff headers. Only changed lines from resolved tasks entered the denominator, but model spend from failed attempts stayed in the numerator. Failed agent runs still cost money.

One successful task contained 16,180 changed lines. The next five largest successful patches contained 136, 129, 86, 81 and 79 lines. That single result supplied 76% of all successful changed lines, so I removed the entire task from both the cost and LOC totals.

attempted tasks             499
resolved tasks              390
accepted changed LOC      5,077
resolve rate              78.2%

Those 499 attempts consumed 651.27 million tokens. I repriced the measured fresh input, cache reads and output tokens at GPT-5.6 Sol’s current promotional rates: $4, $0.40 and $20 per million tokens respectively.

total model spend             = $577.48
cost per accepted changed LOC = $577.48 / 5,077
                              = $0.1137

The more expensive failure is cognitive surrender

The dollars answered my original question, but they also explained why reviewing agent-generated code feels so bad.

A coding agent types fast and, unless you stop it, decides how the change should work, chooses the boundaries, handles the awkward cases, writes the tests and presents the finished result. The human reviewer receives the end product and has to reconstruct all of those decisions from the diff.

The agent makes the engineering decisions, leaving you to audit them afterwards.

Doing that audit properly now costs more than generating the code did. As agents produce more code, the available review time does not expand with them. People stop forming an independent view. They scan the patch, see green tests and approve it.

Addy Osmani describes this as "Cognitive Surrender". Cognitive offloading means delegating work to AI while still owning the answer. Surrender happens when “the AI’s output quietly becomes your output” before you have constructed an answer of your own.

That is a good description of a large AI-written pull request. The reviewer can pay the full cost of reverse-engineering the agent’s decisions, or accept the result without understanding it. The second option is faster and can look exactly like code review from the outside. The pull request looks reviewed and the ticket moves to done.

Those unexamined changes accumulate as comprehension debt.

Every merged decision that nobody on the team made or understood reduces how much of the system the team can explain. Agents continue shipping code faster than people learn it. Eventually, the next difficult change forces somebody to rebuild that missing understanding under pressure.

Line-by-line review was already expensive. With coding agents, it also happens too late.

Move engineering back one layer of abstraction

We need to move the work humans do one layer back.

Engineers should write Plans instead of code. They should decide the approach and its constraints while those decisions are still easy to discuss. Teams should peer-review those Plans instead of waiting for a completed implementation. Once the Plan is agreed, an agent can write the code.

This means the humans form their view first. The agent implements an agreed engineering decision rather than supplying both the decision and the evidence used to approve it.

The resulting pull request still needs to be checked, but the question changes. The Plan states the intended design upfront. You check whether the implementation matches it and spend human attention only where it differs, or where implementation quality requires it.

You keep the useful part of peer review: another person challenges the approach and records why the change was made. They also learn how the system is changing. You remove the part where expensive people read cheap code after every interesting decision has already happened.

This is how we build software at Until. We made the workflow available as an open-source plugin for Cursor, Claude Code, Codex, OpenCode and Pi.

The plugin helps you write and review a Plan before implementation. It keeps the agent working against that Plan, then checks the pull request for differences.

Install the Until plugin and try it on your next agent-written change: github.com/until-dev/plugins

Originally published on LinkedIn ↗