AI Just Made Excellent Work Much Cheaper

The last 5% always costs the most

Taking work quality to 95% used to cost three times what stopping at 80% cost. In theory, it now costs about the same.

Quality has tiers: 80% is good enough, 90% is very good, 95% is great, and nothing is ever 100% done. Each step up has always cost more than the previous one. Going 90 to 95 hurts more than 80 to 90, and you can feel it. Capers Jones’s defect-removal data shows the same shape in software, roughly a 33/36/51 split across the three steps. Biology explains why the staircase feels steep: people drift toward the lower-demand option without noticing they are choosing it.

That quality staircase priced one thing: execution. And execution just changed the owner.

AI took the execution. Verification stayed yours.

Specs were always cheap as artifacts. Describing well, which is the judgment call about what matters, costs more or less the same whether you aim at 80% or 95%. What scaled with ambition was the doing, and AI now takes it. What stays yours is describe and check, and checking grows with the target.

The measured figures come from code, the one domain instrumented this closely. This principle is valid in general. In contract writing, a marketing analysis, campaign planning.

A major study of professional code review found reviewer effort goes mostly into comprehension and rebuilding the reasoning behind the work; spotting defects is the smaller share. Addy Osmani’s read of AI-assisted coding lands in the same place: past 80%, failures turn conceptual, and what he calls comprehension debt piles up when people approve work they cannot explain. Checking a market analysis is the same act. You re-derive the logic, or you admire the formatting.

The bill moved from doing to checking, because checking catches the failure class AI introduces: conceptual mistakes with a polished form.

95% now costs about what 80% used to

Run the math of doing (mostly) any work. Counted in your hours and attention: taking one piece of work to 80% cost a flat 100. 90% another 100. And the full climb to 95% cost about 300.

AI now does the execution, so you pay only your slice: describe and check. Pre-AI data prices that slice at roughly a quarter to a third of the work (code review, 10 to 15%; requirements, 6 to 8%; requirements plus test writing, about 14%).

So each of the three tiers now costs only the verification price. The whole climb to 95% now costs about 90 units of time & attention. That is roughly the same as the old 100 units that bought 80% quality.

One thing voids the napkin: size. Checking runs on attention, and output too big to check means you’re hoping for 95% quality rather than buying it. So you need to work in smaller chunks.

The derivation leans on two small words: “and check.”

Your AI quality ceiling is your verification ceiling

The derivation pays out only if the check is real, and a real check has requirements most of us are failing.

You can only deliver the quality you can verify. A real check takes three things.

• A domain standard: knowing what 95% looks like before you see the output.
• Chunks small enough to check.
• Substance probes: edge cases, one deep spot-check, making the tool show its reasoning.

Surface signals are dead. AI produces polished output at every quality level, so fluency, formatting and confidence no longer separate great from adequate.

The evidence here is the strongest in the article. In experiments, experts accepted subtly corrupted AI code in 70 to 90% of cases depending on the setup, and security experts did no better. Outside code, physicians given flawed AI advice lost 14 points of diagnostic accuracy in a randomized trial (small trial, one country; directional). And humans supervising AI scored 0.71 where the AI alone scored 0.75. That study measured supervision as practiced, approving rather than probing, which is exactly the distinction.

Delegating the check to a model reproduces the failure: LLM judges miss deliberate quality drops more than half the time, so a second model can assist, but it’s never the ultimate solution. Under load, people simply lower the verification bar: as one enterprise scaled AI output, substantive review fell from 39% to 21% of pull requests.

Chunks have to stay small because attention has a hard biological cap: you can verify what fits in one honest session, and no more.

Your quality ceiling is your verification ceiling. Everyone got the same discount on the execution, so to stay at the top of the field, you have to verify the AI output thoroughly.

The money is in telling 95% quality from 80% quality

The checking ceiling decides everything now, because generating work to 80% quality is cheap enough that 80% floods what you read and ship. Content, code, analysis, each moving fast with its flaws riding under the polish. It feels like progress, but producing a lot of low-quality work is actually a step backwards.

The correct move is to slow a notch and be thorough about the verification of your output. It comes in layers: a test suite, a second model interrogating the first, your own line-by-line read. What makes them checks is the standard behind them.

So nowadays, the advantage is verification capacity: telling 95% from 80%. How rare reliable verifiers are, nobody has measured; the failures above are what we have, plus this: 66% of the 31,476 developers who answered name AI output that is “almost right but not quite” as their biggest frustration, and almost right is the territory this 80-to-95 shorthand describes.

Stack 80% on 80% and you get nowhere

That “I deliver 95% quality” edge compounds past the single piece of work. A goal, business or personal, is a chain of delivered projects. Stack 80% on 80% and the flaws compound: every link adds noise, and you get nowhere in particular, quickly.

Stack great work on great work and each step drifts less, so you arrive sooner. Sometimes at a place you never consciously chose, and that arrival is what exposes a wrong goal, but only if you verified the output honestly along the way.

The discount buys everyone the same speed of creating work. Verification skills truly decide how well you are going to play with AI. Excellence got cheap.

Key takeaways

• Quality has tiers, 80/90/95, and each higher tier has always cost more than the last. That staircase priced execution, and AI just took it.
• Your remaining job is describe and check, and checking grows with the target.
• The napkin: the climb to 95% now costs about 90, against 300 the old way. Roughly what 80% alone used to cost.
• You can only deliver the quality you can verify: domain standard, small chunks, substance probes. Polish signals nothing anymore.
• The edge is telling 95% from 80%, and experts accept corrupted work 70% to 90% of the time, so that capacity is rare.

---

Where the numbers come from

• Capers Jones, “Software defect-removal efficiency,” IEEE Computer 29(4), 1996: https://doi.org/10.1109/2.488361 (accessed 2026-07-28; primary paywalled, figures consistent across secondary sources, MEDIUM-HIGH).
• Kool, McGuire, Rosen, Botvinick, “Decision making and the avoidance of cognitive demand,” J. Exp. Psychol. General 139(4), 2010: https://pubmed.ncbi.nlm.nih.gov/20853993/ (accessed 2026-07-28).
• Bacchelli, Bird, “Expectations, Outcomes, and Challenges of Modern Code Review,” ICSE 2013: https://www.microsoft.com/en-us/research/publication/expectations-outcomes-and-challenges-of-modern-code-review/ (verified 2026-08-03).
• Addy Osmani, “The 80% Problem in Agentic Coding,” Jan 2026: https://addyo.substack.com/p/the-80-problem-in-agentic-coding (re-fetched 2026-07-29).
• MacLeod et al., “Code Reviewing in the Trenches,” IEEE Software 2017: https://chisel.cs.uvic.ca/pubs/macleod-IEEESoftware2017.pdf (accessed 2026-07-28; n=900+).
• COCOMO II Model Definition Manual, USC 2000: https://athena.ecs.csus.edu/~buckley/CSc231_files/Cocomo_II_Manual.pdf (accessed 2026-07-28).
• IDC 2024 via InfoWorld: https://www.infoworld.com/article/3831759/developers-spend-most-of-their-time-not-coding-idc-report.html (accessed 2026-07-28).
• Oh et al., IEEE S&P 2024: https://arxiv.org/abs/2312.06227 (accessed 2026-07-28; experimental conditions).
• Qazi et al. (preprint): https://www.medrxiv.org/content/10.1101/2025.08.23.25334280v1 (accessed 2026-07-28; n=44, single country).
• Recchia et al.: https://arxiv.org/abs/2507.19486 (accessed 2026-07-28).
• Doddapaneni et al., EMNLP 2024: https://arxiv.org/abs/2406.13439 (accessed 2026-07-28).
• He et al., arXiv:2607.01904: https://arxiv.org/abs/2607.01904 (accessed 2026-07-28; single enterprise; as of July 2026).
• Stack Overflow Developer Survey 2025: https://survey.stackoverflow.co/2025/ai (re-verified 2026-08-03; 66% of 31,476 respondents to the frustration question; as of July 2026).

This landscape moves monthly; treat the 2026-dated sources as current only as of July 2026.