← Reports

Report · AI in IT operations

More code, less confidence

Where quality breaks in agile teams — what DORA 2025, GitClear, LinearB and Stack Overflow data say about why scrum teams ship worse code, and the habits of the teams that don't.

Jose Constela (Founder, Lab34) 7 min read Download PDF

Agile teams merge more code than ever. They trust it less than ever.

Three numbers frame the problem.

63%

of organizations struggle to deliver reliable, high-quality software — 12 points worse than a year earlier

18th State of Agile Report

95%

of developers now use AI tools at work

DORA 2025

33%

trust the accuracy of what those tools produce — down from 43% in 2024

Stack Overflow Developer Survey 2025

Sources for those figures, in order: the 18th State of Agile, DORA 2025 and Stack Overflow 2025.

The sprint ceremonies didn’t change. The economics of code did. This is what the recent data says about where quality breaks in scrum teams, and what the teams that escape it do differently.

The bottleneck moved from writing to reviewing

For twenty years the constraint was writing code. That constraint is gone, and the queue moved downstream.

LinearB analyzed 8 million pull requests. AI-assisted PRs are 2.5x larger than human-authored ones: 400 changed lines against 157 at the 75th percentile. They wait 5x longer for a first review — 16+ hours against roughly 3.3. And they merge at 32.7%, less than half the 84.5% rate of human-authored work.

There is a darker detail in the same dataset. Once review finally starts, AI-heavy PRs get approved faster than human ones. Reviewers are not being more careful with bigger diffs. They are skimming them.

The downstream bill shows up in Faros telemetry: incidents per PR up 242%, bugs per developer up 54%, median review time up 441%.

Bar chart: PR size +154%, PRs merged +98%, review time +91%, tasks completed +21%, in the teams with the highest AI adoption.
Output and review load rise together — and review rises against a fixed number of reviewers. A year on, median review time is up 441% and 31% of PRs merge with no review at all. Faros AI, telemetry from 10,000+ developers across 1,255 teams · from the Lab34 study, p. 6

If your sprints feel slower while everyone claims to move faster, this is usually where the time went.

Maintainability is eroding, and it is measurable

GitClear tracks how code changes year over year, across hundreds of millions of changed lines. Their 2026 report reads like a slow leak.

Duplicated code blocks are up 81% in three years — the highest level on record. Refactored (“moved”) code collapsed from 21% of changes in 2022 to 3.8% in 2026. Copy/paste grew from 9.4% to 15.7%. Updates to legacy code fell 74%, and cross-file reuse of existing functions fell 35% since 2023.

Bar chart of code-structure changes since 2022: block duplication +81%, error-hiding constructs +47%, copy/paste in commits +41%, two-week churn +15%, links to existing code −35%, refactoring −70%, legacy code maintenance −74%.
Everything that adds code is up; everything that consolidates it is down. Copy/paste is now roughly five times as likely as refactoring — in 2022 the ratio ran the other way. GitClear, The Maintainability Gap (2026) · 623M changed lines · from the Lab34 study, p. 7

The pattern is consistent: assistants add new, isolated code instead of reusing what exists.

None of this fails a sprint review. All of it compounds. It is debt taken out in 200 small commits, with no single moment where anyone decided to borrow.

Technical debt still eats the sprint

Debt was the top complaint before AI, and it still is. 62–63% of developers rank technical debt as their #1 workplace frustration, and they report 17+ hours a week on maintenance and debugging. Sonar puts the cost at 20–40% of sprint capacity in debt-heavy teams.

The scrum mechanics feeding it haven’t changed. Under deadline pressure, QA gets compressed first. Scope creeps in mid-sprint. The Definition of Done bends exactly when the burndown looks bad.

What changed is the inflow. 88% of developers report at least one way AI has increased their technical debt: code that looks functional but isn’t reliable (53%), or redundant code the codebase already had (40%).

The “almost right” tax

Stack Overflow’s 2025 survey found the #1 frustration with AI tools: 66% of developers point to solutions that are almost right, but not quite. 45% say debugging AI-generated code takes longer than expected. Belief that AI can handle complex problems dropped from 35% to 29% in a year.

“Almost right” is expensive precisely because it is almost right. It passes the linter. It reads clean inside a 400-line diff. It fails at a service boundary two weeks later.

For estimation this is poison. A story looks 80% done in two days, then stalls in a verification tail nobody planned. The velocity chart says the team sped up. The sprint commitment says otherwise.

That gap between felt and measured speed is the part teams most often plan against. METR put experienced developers through 246 real tasks on their own repositories: they believed AI made them 20% faster, and the stopwatch said 19% slower — a 39-point gap between perception and measurement. METR’s own 2026 update, on a larger sample, lands closer to neutral. Either way, the number to plan with is not the one the team feels.

Two bars: what developers believed, +20% faster; what the stopwatch measured, 19% slower.
Perception and measurement disagree by 39 points. Sprint commitments are made on the left-hand bar. METR, controlled trial with experienced developers, 246 real tasks (Jul 2025; Feb 2026 update) · from the Lab34 study, p. 5

This is a systems problem, not a developer problem

Individual metrics rise almost everywhere — tasks completed, PRs merged. Organizational metrics don’t follow. 63% of organizations still struggle to deliver reliable software, only 27% say agile delivers real value, and just 49% have any governance guardrails for AI use.

Blaming developers for AI-era quality problems is blaming drivers for a road with no lanes.

What the teams that escape it do

DORA profiles the teams that get compounding benefit from AI. Their habits are unglamorous:

Nothing on that list is new. That is the point. AI didn’t change what quality engineering is; it raised the price of not doing it.

It is also the bar we hold our own work to at Lab34: small batches, gates in CI, and a Definition of Done that doesn’t move.

Before you quote these numbers

Sources

The full study, with every chart and the complete source list:

The datasets behind the figures, at first hand:

The articles cited in the text:

Turning the habits into configuration

Basis: Secondary analysis of published industry datasets from 2025–2026 — DORA, GitClear, LinearB, Faros, Stack Overflow, Sonar and the 18th State of Agile Report. No original measurement by Lab34. Several sources are vendors operating in this problem space; figures should be read as estimates and the trend as the finding. Every figure links to its origin. The full 14-page study, with the charts and the complete source list, is available as a PDF.