AI Coding Productivity Stuck at 10% Despite 92% Adoption
By: Evgeny Padezhnov
Adoption of AI coding tools is near-universal. Measured productivity is not.
A survey of 121,000 developers puts the gain at 10%. That number has not moved in over a year. It sits far below the 10x promise that sold the tools in the first place.
Adoption soared. Output barely moved.
Laura Tacho's research at DX surveyed 121,000 developers across 450+ companies. The data ran through February 1, 2026.
The headline figures show saturation, not growth:
- 92.6% of developers use an AI coding assistant at least monthly.
- Roughly 75% use one weekly.
- 26.9% of production code is now AI-authored, up from 22% the prior quarter.
Usage is effectively maxed out. Yet the productivity gain holds at 10%. It plateaued there when AI tools first arrived and stayed flat.
Time savings tell the same story. Developers report saving about 4 hours weekly. Q4 2025 figures landed at 3.6–3.7 hours. The curve went flat, not up.
Key point: usage climbed hard, the payoff did not follow. More tokens generated did not become more software shipped.
The full breakdown is on the DX research blog.
Why the 10% ceiling holds
Coding is a small slice of the workday. DX research puts it at 14% of developer time.
Speeding up 14% of the job cannot transform the other 86%. Code review, meetings, debugging, planning, and waiting on CI consume the rest. AI assistants barely touch those steps.
A separate DX longitudinal study makes the limit concrete. It analyzed 400+ engineering organizations over 16 months. Each had 100+ engineers and 75%+ monthly AI usage.
Over that period, AI tool usage rose 65% on average. Median pull-request throughput rose just under 8%. The mean came in around 11%. Most organizations landed in the 5–15% range.
"A meaningful gain, but far below the 3x or 10x expectations," the report stated.
Common mistake: treating faster typing as faster delivery. Generating code is rarely the bottleneck. Verifying, reviewing, and integrating it is.
Laura Tacho named the cause directly. She called weak results "really a management problem." Adoption alone changes nothing.
In plain terms: AI exposes a team's existing structure. Teams with weak review, testing, and deployment see those gaps widen. AI does not patch a broken pipeline. It pushes more code through it.
The perception gap is large
Developers feel faster. Measurement disagrees. The distance between the two is the most important finding in this whole topic.
METR ran a randomized controlled trial in 2025. It recruited 16 experienced open-source developers. They worked across 246 real tasks from mature repositories.
Each task was randomly assigned: AI allowed or AI prohibited. The tooling was Cursor Pro with Claude 3.5/3.7 Sonnet. The design was the gold standard for cause and effect.
The result surprised the researchers. Developers were 19% slower when AI was allowed.
The belief ran the opposite direction:
- Before the study, developers forecast 24% faster with AI.
- After finishing, they still estimated 20% faster.
Measured reality was 19% slower. The gap was not a rounding error. It was a full reversal of sign.
Tested in production, the feeling of speed and the fact of speed are different metrics. One is a vibe. The other is a number. Track the number.
The mechanism is simple. AI removes the friction of starting a task. It adds friction in reviewing and correcting the output. The first saving is visible. The second cost is easy to miss. On unfamiliar code, the correction cost can swamp the head start.
Who actually gets more than 10%
The 10% figure is a median. Some teams beat it. The survey distribution shows who, and why.
Only 16.3% of developers said AI helped to a great extent. The largest group, 41.4%, reported little or no effect. The same tools produced opposite outcomes.
That spread points to conditions, not the assistant. Teams that gain more share concrete traits:
- Strong test coverage catches AI errors before they reach production.
- Fast CI shortens the generate-then-verify loop.
- Clear code ownership keeps review quality high under more volume.
- Well-scoped tasks match what models actually do well.
The 26.9% AI-authored figure raises a hidden cost. More generated code means more code to review. Review capacity becomes the new constraint.
In practice, the gain concentrates in narrow tasks. Boilerplate, unit tests, regex, config files, and unfamiliar-language syntax respond well. Architecture decisions, cross-system debugging, and subtle concurrency bugs respond poorly.
Common mistake: counting saved keystrokes and ignoring added review time. Net gain is the only figure that matters. A faster first draft that needs a longer review is not a win.
What the saved time does not become
There is a second paradox under the first. Even when developers save hours, the saved time often vanishes.
The time freed by AI is frequently not redirected toward higher-value work. It gets absorbed by context-switching, more meetings, or simply more low-value tickets. The slack does not convert into outcomes a business can measure.
This is why org-level metrics lag individual feeling. A developer finishes a function faster and feels productive. The team's cycle time and deployment frequency stay flat. Both observations are true at once.
If it works — it is correct. So measure the thing that defines "works" for the business. Shipped value, not generated lines.
How to measure it honestly
Sentiment surveys mislead here. The METR result proves perception is an unreliable gauge. Use checkable signals instead.
Track the DORA metrics across a real time window:
- Deployment frequency.
- Lead time for changes.
- Change failure rate.
- Time to restore service.
Pair them with throughput. Pull-request count per engineer is a coarse but honest proxy. A simple git log --since over a quarter gives a baseline without new tooling.
Run a clean before-and-after. Hold the team and the process constant. Change only the AI tooling. Compare the same metric across two equal periods.
Watch the failure rate, not only the speed. AI can raise throughput while quietly raising defects. A 10% throughput gain with a higher change failure rate is a net loss.
Avoid optimizing the metric itself. If review headcount stays fixed while AI output doubles, review quality drops. The throughput number can rise while real quality falls. Measure outcomes, not activity.
What this means for tooling budgets
The data does not say drop AI assistants. A 10–15% gain is real. It usually justifies the per-seat cost of Copilot or Cursor.
The data says set honest targets. Promise a measured 10%, not an imagined 10x. Plan capacity and deadlines against the real figure.
Spend on the system, not just the model. Faster CI, better test coverage, and clear ownership unlock more than a newer assistant. The 86% of the day that is not coding holds the larger prize.
Match the tool to the task. Point AI at boilerplate, tests, and syntax in unfamiliar languages. Keep a human firmly on architecture and hard debugging. The model is a strong junior on narrow work, not a senior on judgment.
What to try right now
Pick one team. Measure its pull-request throughput and change failure rate for four weeks. Do not change any tools yet.
Try it: compare that window against the prior quarter using git log and your CI dashboard. If the AI-era gain is under 10%, the assistant is not the bottleneck.
Then look at the 86% of the day that is not coding. Find the slowest step there — slow CI, a review queue, flaky tests. Fix that step first. It will return more than any model upgrade.
Sources:
Information is accurate as of the publication date. Terms, prices, and regulations may change — verify with relevant professionals.