"AI made me faster" is the assumption. "AI made me 19% slower on these tasks" is the finding. The gap between them is the most useful thing you can study.
TL;DR
- A landmark study (METR) found experienced developers were ~19% slower on certain tasks with AI assistance.
- The cost is not generation — it is reviewing, debugging, and verifying AI output.
- This is the "80% problem": AI gets you most of the way instantly; the last mile needs human judgment.
- The fix is workflow design, not abandoning AI.
The counterintuitive result
It is easy to assume AI assistance is a pure speed-up. A careful study by METR complicated that: experienced developers working on tasks in their own codebases took roughly 19% longer with AI tools than without — even though they felt faster. The perception and the measurement pointed in opposite directions.
This is not an argument against AI. It is a precise description of where the cost actually lands.
Where the time goes
Generation got cheap. The expense moved downstream:
- Reviewing code you did not write is slower than reviewing your own — you have to build the mental model from scratch.
- Debugging confident-but-wrong output means first realizing it is wrong, which can be subtle.
- Re-prompting to fix issues burns time and tokens in a loop.
- Context-switching between directing the AI and verifying it has its own overhead.
AI removes the cost of the first draft and adds the cost of trusting it. If the second exceeds the first, you are paying the verification tax.
The 80% problem
The pattern behind the number: AI gets you ~80% of the way almost instantly, and the final 20% — correctness, edge cases, fit with the existing system — demands rigorous human judgment. That last 20% is where the real engineering lives, and it does not compress just because the first 80% did.
How to lower the tax
The verification tax is not fixed. You reduce it by designing the workflow so verification is cheap:
- Give the agent a verifiable target. A passing test suite, a type check, a linter — let "correct" be something the agent can check itself before handing it to you.
- Work in small, reviewable slices. A 50-line change you can fully reason about beats a 500-line one you skim and hope.
- Match the tool to the task. AI pays off most on boilerplate and well-bounded work; it pays off least on novel, ambiguous, deeply contextual problems — exactly where the study found slowdowns.
- Invest in tests up front. Good test coverage turns verification from manual reading into an automated signal.
The honest takeaway
The most valuable engineers are not the ones who generate the most code — they are the ones who verify fastest and most reliably. The 19% number is a gift: it tells you exactly which part of the job AI did not make easier, so you can engineer around it instead of pretending it does not exist.
Use AI where it lowers total time, not where it just lowers time-to-first-draft.