When Model Evaluation and Threat Research (METR) asked 16 experienced developers to complete 246 real-world tasks, half with AI tools and half without, they expected AI to deliver the promised productivity gains. Developers forecast a 24% speedup. Instead, AI caused a 19% slowdown—and developers still believed they were 20% faster. This 39-point perception gap reveals a measurement crisis costing the industry billions.
The Data Contradicts the Belief
METR’s early 2025 study used a rigorous randomized controlled trial. Participants had median 10 years of open-source experience and worked on their own repositories using Cursor Pro with Claude 3.5/3.7. The result: tasks took 19% longer with AI (confidence interval: +2% to +39%). Additionally, a follow-up study with 57 developers across 800+ tasks showed a -4% slowdown—less negative, but still not the gains vendors promise.
Why the disconnect? Developers focus on typing speed. AI generates code instantly, creating the sensation of velocity. However, total task time tells a different story. Developers accepted only 44% of AI-generated code. The rest required review, testing, modification, and ultimately rejection. Even accepted suggestions consumed time for cleanup and refitting to project context. As METR researcher Nate Rush explained, “Developers have to spend a lot of time cleaning up the resulting code to make it actually fit for the project.”
Cognitive Biases Create Measurement Blindness
Optimism bias and the planning fallacy explain why developers misjudge their own productivity. Research shows 70% of developer actions are associated with at least one cognitive bias. Developers notice they’re typing less and shipping more code. GitClear’s 2026 analysis confirms this: developers using AI throughout the day produce 4x to 10x more work than non-users. That volume feels like productivity.
It isn’t. Output volume measures lines of code committed, pull requests merged, features shipped. These are vanity metrics. Actual productivity requires measuring task completion time, system stability, and technical debt accumulation. Consequently, organizations optimizing for velocity ignore the downstream costs piling up in code review queues, debugging sessions, and production incidents.
The Quality Tax Is Real
GitClear tracked code quality across 2,172 developer-weeks, analyzing data from Cursor, GitHub Copilot, and Claude Code. The findings are stark: AI-assisted coding produces 4x more code cloning than pre-AI development. During 2024, code blocks with five or more duplicate lines spiked 8-fold—ten times higher than two years ago. For the first time in software development history, developers paste code more often than they refactor or reuse it.
This isn’t free. Gartner estimates over 40% of IT budgets are consumed by technical debt. Duplicated code multiplies bugs, inflates cloud storage costs, and creates testing nightmares. Moreover, Google’s 2024 DORA report found that a 25% increase in AI usage quickens code reviews but results in a 7.2% decrease in delivery stability. The throughput improvement at the front end erodes into instability at the back end.
Technical debt from AI-generated code compounds differently than traditional debt. Three vectors accelerate accumulation: model versioning chaos, code generation bloat, and organization fragmentation. Layering AI code onto legacy systems—already carrying hidden debt—creates tangled dependencies that destabilize systems faster than teams can remediate them.
Trust Without Verification Is Theater
Sonar’s 2026 State of Code Developer Survey, which polled 1,149 developers globally, uncovered a dangerous gap. While 96% of developers don’t fully trust AI-generated code, 72% who tried AI use it every day. The critical failure: only 48% always verify AI code before committing. That means 52% commit code they don’t trust without checking.
Why? Because verification is exhausting. Teams now spend 24% of their work week—nearly a full day—checking, fixing, and validating AI output. As AI-generated code grows from 42% of commits in 2026 to an expected 65% by 2027, the verification bottleneck will only worsen. The old constraint was writing code. The new constraint is reviewing it.
Worse, 61% of developers agree that “AI often produces code that looks correct but isn’t reliable.” Subtle bugs embedded in plausible-looking logic bypass automated testing. Security vulnerabilities hide in code that compiles cleanly. The verification burden isn’t just time-consuming—it requires expertise to spot hallucinations that surface as production failures weeks later.
Why AI Slows Experienced Developers
METR’s study identified four friction points. First, context gaps. AI lacks project-specific knowledge developers possess from years of working in a codebase. Second, code cleanup burden. Refitting generic AI output to project conventions consumes significant time. Third, prompt engineering overhead. Crafting prompts, refining them, and iterating to get usable output is work. Fourth, processing delays. Waiting for AI to generate code—especially with agentic tools running multi-step workflows—introduces latency.
Anders Humlum, a University of Chicago economist who studies AI’s labor impact, summarized the problem: “Skilled workers may see diminishing returns. Companies shouldn’t force experienced professionals to adopt AI if current methods work effectively.” MIT economist Daron Acemoglu goes further, estimating that only 4.6% of U.S. economy tasks will see meaningful AI efficiency gains.
This suggests bifurcation. AI may help junior developers with boilerplate and Stack Overflow-style queries. For experienced developers working on complex, context-heavy problems in mature codebases, AI adds friction faster than it removes it.
The ROI Illusion
Engineering leaders are flying blind. A 2026 survey found 86% feel uncertain about which AI tools provide actual benefit, and 40% lack sufficient data to justify ROI. Standard ROI calculations assume productivity gains exist. Break-even analysis from Zylo suggests professionals saving 2-3 billable hours per month recoup the $40/month cost. That math works if tools save time. METR’s study shows they don’t—at least not for experienced developers on real-world tasks.
If AI slows developers by 19%, subscription cost becomes irrelevant. The real cost is lost engineering time, compounding technical debt, and degraded system stability. Consequently, organizations betting billions on AI coding tools are measuring the wrong metrics and trusting feelings over data.
What Organizations Should Measure Instead
Stop tracking lines of code, pull requests merged, and sprint velocity. These metrics reward volume, not value. Start tracking task completion time from assignment to deployment, technical debt growth via code duplication and churn metrics, and system stability through incident rates and MTTR. Measure verification burden by tracking time spent reviewing, debugging, and refactoring AI-generated code.
Most importantly, run controlled experiments like METR did. Randomly assign tasks to AI vs. non-AI workflows and measure total time to completion. Survey developer sentiment, but don’t conflate satisfaction with productivity. Developers feeling faster while working slower is a problem, not a success metric.
The AI coding tools market hit $7.37 billion in 2025, with 84% of developers now using AI and 92.6% trying it at least monthly. Adoption is universal. Productivity gains are not. Until organizations measure outcomes instead of outputs, they’ll keep investing in tools that feel productive while delivering slowdowns, code quality decline, and technical debt accumulation.
The emperor isn’t naked. He’s just 19% slower, and nobody’s measuring.
