Article

AI Coding Is Fast. Here's What It Actually Costs

AI Coding Is Fast. Here's What It Actually Costs

A member of LINUX DO asked the question the whole industry keeps dancing around: AI coding has delivered its efficiency revolution — so what's the price? It's the rare question that gets sharper the longer you look at it, because the answer isn't a number on an invoice. The bill arrives as hours spent reviewing code you didn't write, as codebases that grow messier the more "help" they get, and as a strange gap between how fast developers feel and how fast they actually ship.

The short version: the research now itemizes the costs. A randomized trial found experienced developers took 19% longer with early AI coding tools while believing they were 20% faster. Codebases measured across 211 million changed lines show duplication climbing and refactoring collapsing. And in the largest developer survey on earth, 46% of respondents actively distrust AI accuracy — more than trust it. None of this means AI coding is a bad deal. It means the price moved from typing to thinking, and most teams haven't updated their accounting.

The 40-point gap between feeling fast and being fast

The most startling number comes from a randomized controlled trial by METR, published in July 2025 (paper). Sixteen experienced open-source developers worked through 246 real issues in repositories they knew well — codebases averaging over a million lines, with about five years of prior contribution history each — with AI assistance randomly allowed or disallowed per task. The developers predicted a 24% speedup. After finishing, they believed the tools had saved them 20% of their time. The clock said the opposite: with AI allowed, tasks took 19% longer (95% confidence interval: 2% to 39% slower).

That roughly 40-point gap between belief and measurement is the finding that matters most, because it's about human judgment rather than any particular model. Self-reported productivity — the basis of nearly every vendor claim — is systematically miscalibrated in the optimistic direction. Developers feel faster because generating code feels like progress; understanding, checking, testing, and integrating it is where the hours quietly go.

Honesty requires the update. METR has since flagged that result as historical: in a February 2026 follow-up with 57 developers and 800+ tasks on late-2025 agentic tools, the estimate flipped to an 18% speedup for returning developers (and 4% for new recruits) — but with confidence intervals crossing zero, and METR itself calling it "only very weak evidence," partly because developers increasingly refused the no-AI control condition at all. The tools got better. The perception gap didn't close. If anything, the fact that researchers can no longer get developers to work without AI tells you the tools are indispensable now — while telling you nothing reliable about how much faster they make anyone.

The code rots differently now

If the first cost is invisible — your own miscalibrated sense of speed — the second is measurable in the repository. GitClear's analysis of 211 million changed lines of code from 2020 through 2024 found that AI-assisted coding changed what kind of code gets written:

Code operation~2021 (pre-AI baseline)2024
Copy/pasted lines~8.3–8.9% of changed lines~12.3%
"Moved" (refactored) lines~24% of changed linesunder 10%
Blocks of 5+ duplicated linesbaseline~8× the baseline

2024 was the first year in the dataset's history where copy-pasted lines exceeded refactored lines. An earlier GitClear report, "Coding on Copilot", projected that code churn — lines rewritten or reverted within two weeks of authorship — would double versus the pre-AI baseline.

The mechanism is almost too simple: an AI assistant makes accepting a duplicate a single keystroke, while refactoring still demands the hard cognitive work of understanding module boundaries and updating call sites. The path of least resistance now runs downhill toward duplication. Fast code, it turns out, is often code that gets rewritten.

One caveat, stated plainly: GitClear sells code-quality tooling, so this is vendor-published, observational research. The direction of the trend is corroborated by independent coverage, but treat the exact multiples as one company's measurement, not physics.

Faster typing, shakier shipping

Google's DORA research program — the industry's long-running study of software delivery performance — caught the same dynamic at the organizational level. The 2024 report, covering roughly 39,000 respondents, found that a 25% increase in AI adoption was associated with a 7.2% decrease in delivery stability (and a small 1.5% dip in throughput), attributing it to larger batch sizes: more code arriving at once, reviewed and deployed in bigger chunks.

The 2025 DORA report — nearly 5,000 professionals surveyed in mid-2025 — updated the picture: throughput flipped positive, but the stability penalty persisted for a second year. The researchers' framing is that AI amplifies whatever system it's dropped into: generation now outpaces the organization's ability to review, test, and absorb it. Speed without stability is accelerated chaos.

This is the cost that shows up in production incidents, not in demos. The pipeline was sized for humans typing at human speed, and it's now drinking from a firehose.

Trust is the scarcest resource

The Stack Overflow Developer Survey 2025 (about 49,000 respondents) put numbers on the trust deficit directly: 84% of developers use or plan to use AI tools — up from 76% a year earlier — yet more developers actively distrust AI accuracy (46%) than trust it (33%), and only about 3% highly trust the output. Positive sentiment toward AI fell from 72% to 60% year over year. The top complaint isn't that AI can't write code; it's that it writes solutions that are "almost right, but not quite" (66% of respondents), and 45% say debugging AI-generated code is more time-consuming.

That "almost right" failure mode is the expensive one. Code that's obviously wrong gets rewritten immediately; code that looks right, compiles, and passes a casual review gets merged — and debugged at 2 a.m. by someone else. As developers keep discovering in the agent era, the review burden is the real bottleneck: every line the machine writes still has to be read by a human who understands it, a dynamic we explored in the CLI-vs-desktop agent debate.

The human line item: skill erosion and old-school nostalgia

Then there's the cost no dashboard captures. In a separate LINUX DO thread that drew 46 replies and over 1,500 views, developers half-jokingly confessed to missing "old-school programming" — writing code by hand and actually understanding every line (thread; summarized here, not quoted). Beneath the nostalgia sits a real worry, echoed in the cost-of-AI-coding thread (thread): if the agent writes the tricky parts, do junior developers ever learn to debug them? If you can't explain why the code works, is it yours — or borrowed?

Reported-speech discipline applies: these are forum members' self-reported anxieties, not controlled findings. But they rhyme with the data above. A workforce that generates faster than it understands is a workforce whose review capacity becomes the binding constraint — which is exactly what the trust numbers describe.

Keeping the speed without paying full price

None of this is an argument for going back. The follow-up evidence says the tools are genuinely improving, and developers now refuse to give them up — revealed preference is hard to argue with. The practical question is how to bank the speed while controlling the costs, and the same research points at the levers:

  1. Review everything, and budget for it. If AI makes generation cheap and verification expensive, put the expensive part in the schedule. Treat review time as the real cost of each agent-written diff.
  2. Keep diffs small. DORA's batch-size finding cuts both ways: small, frequent changes are both more stable and easier to review. Ask the agent for surgical changes, not sprawling rewrites — and make it plan first when the change is architectural.
  3. Tests are the contract. The cheapest way to trust code you didn't write is a test that proves it works. Generating the tests alongside the code — and actually running them — converts "almost right" from a 2 a.m. problem into a compile-time one.
  4. Schedule refactoring explicitly. GitClear's data says refactoring is dying of neglect, not impossibility. If nobody schedules it, the one-keystroke duplicate wins by default. Make "remove the duplication the agent introduced" part of the definition of done.
  5. Verify the feeling. The METR gap is a warning about self-reporting: time a few real tasks with and without assistance before declaring a 10x win. Your stopwatch is more honest than your memory.

The bill always arrives

The efficiency revolution was real — it just relocated the work instead of removing it. Typing got cheaper; thinking, reviewing, and maintaining did not. The developers asking "what's the price?" on LINUX DO have the right instinct: every technology that makes producing something cheap eventually bills you for consuming it. Code is no exception.

The honest accounting is neither "AI coding is a scam" nor "AI coding is free money." It's this: you are trading keystrokes for judgment. Judgment is the scarce, expensive, non-outsourceable part — and the teams that treat it that way get to keep the speed. The ones that don't will find the bill in their codebase, compounding quietly, until someone has to pay it down by hand. Perhaps that's what the nostalgia for old-school programming is really about: not the typing, but the certainty that every line in the file was understood by the person who put it there.

Keep reading
REA: The Open-Source Toolkit That Gives Your AI Agent a Decompiler
Read next →