IDC tracked 250,000 developers and found the median codes 52 minutes per day. Forrester puts it at 24% of work time. Microsoft's internal study: 11%. Yet we built an entire industry to optimize that slice — and delivery metrics stayed flat.
The median developer writes production code for 52 minutes per day.
That's not my number. That's Software.com's, from monitoring over 250,000 developers across thousands of companies. Fifty-two minutes. About 4.3 hours per week. Roughly 11% of a standard workweek.
IDC put it at 16% in their 2025 survey. Forrester found 24%. A Microsoft internal study of 484 of their own engineers clocked actual coding time at 11% — against an ideal the engineers themselves wanted of around 20%.
Every number is different. Every number is small.
And yet we built an entire industry — Copilot, Cursor, Claude Code, Devin, Codium, and a hundred others — specifically to speed up those 52 minutes. We measured success in tokens per second, autocomplete acceptance rates, lines generated per hour.
Meanwhile, software delivery metrics went flat.
The Math Nobody Wants to Do
Amdahl's Law is one of those things every CS student learns and every engineering leader ignores. It describes how much total speedup you get when you improve only part of a system:
Total speedup = 1 / ((1 - P) + P/S)
Where P is the fraction of work you're improving, and S is how much faster you've made it.
If coding is 30% of the development lifecycle — a generous figure by most surveys — and AI makes it twice as fast, the total improvement to your delivery pipeline is:
1 / (0.70 + 0.15) = 17.6%
If AI makes coding ten times faster — genuinely science fiction for most real tasks — you get:
1 / (0.70 + 0.03) = 37.6%
That's the ceiling. Even in the most optimistic scenario, a 10x speedup on coding translates to a 37% improvement in total software delivery. And in practice, the real ceiling is lower, because AI coding tools don't make the work 10x faster — they make some of it faster while creating new work downstream.
This isn't a knock on AI tools. It's physics. You can't optimize your way to 2x delivery speed by improving a 20% slice of the process, no matter how sophisticated the tool.
Where the Other 80% Goes
If coding is 16–24% of developer time, what's the rest?
IDC's "How Do Software Developers Spend Their Time?" report (February 2025) is the most granular breakdown I've seen. Across their survey cohort:
Notice what's dominant: the operational and quality layers. CI/CD, deployment, monitoring, security, and testing together dwarf the coding slice. And these are precisely the activities that most AI coding assistants don't touch.
The Microsoft Time Warp study found that developers spend more time in meetings (12% of actual time) than writing code (11%). Stack Overflow's 2024 survey of 90,000 developers found that 62% cite technical debt as their primary frustration — not "I can't type fast enough," but "I'm always fighting the mess from before."
The bottleneck was never the keyboard. It was everything around it.
What AI Did to the Pipeline
Here's the perverse part: AI coding tools didn't just fail to solve the bottleneck. For many teams, they made it worse.
Faros AI tracked 10,000+ developers across 1,255 teams and found that teams with high AI adoption showed:
• Pull requests merged: +98%
• PR size: +154%
• PR review time: +91%
• Bug rates: +9%
• DORA delivery metrics: flat
More code. Same throughput. More bugs. More review burden.
The CodeRabbit study of 470 open-source pull requests found that AI-written PRs contain 1.7x more issues than human-written PRs — including 1.4x more critical bugs and 1.75x more logic and correctness errors.
GitClear analyzed 211 million lines of code across major repositories from 2020 to 2024. Code churn — lines revised within two weeks of commit — rose from 3.1% to 5.7%. Copy-pasted code blocks rose 48% relative to 2021. "Moved" (refactored) lines dropped from 24% to 9.5% of all code changes.
What AI produces faster is also revised faster. The rework is baked in.
Cursor, to their credit, noticed. Their CEO Michael Truell acknowledged it directly: "Cursor has made it much faster to write production code. However, for most engineering teams, reviewing code looks the same as it did three years ago." Then Cursor acquired Graphite for around $290 million — a code review platform. That acquisition is a thesis statement. It says: we made the generation side faster, and now the constraint is clear.
The CI/CD Wall
There's an insight from Kyle Galbraith at Depot that I've been thinking about since I read it: "AI can help write your feature in 20 minutes. But if your CI pipeline also takes 20 minutes, you've just traded one bottleneck for another."
This is the part that doesn't get enough attention.
A developer using Claude Code or Cursor can take a well-specified task from zero to working implementation in minutes. But then what? The PR goes into a queue. CI runs. If CI is slow — 20, 30, 40 minutes — the developer context-switches. The PR waits. The review waits. The merge waits.
LinearB's 2025 benchmarks across 8.1 million pull requests found that the median cycle time is 83 hours from first commit to merge. Elite teams are under 48 hours. Most teams are nowhere close.
Logilica data puts the median time waiting for code review at 13 hours at large companies. That's 13 hours of idle time for code that may have taken 20 minutes to write.
LogRocket's analysis is direct: senior engineers spend 4.3 minutes reviewing AI-generated code versus 1.2 minutes for human-written code. AI suggestions require more scrutiny precisely because they're produced without the reviewer's context, experience, or awareness of what they don't know.
You speed up generation. You slow down review. The net effect depends on which is your actual constraint — and for most organizations, it's the review.
What's Actually Worth Optimizing
If you accept that coding is 16–24% of developer time, the optimization target becomes obvious: everything else.
The teams I've seen actually improve delivery velocity share three patterns:
Invest in CI/CD speed before AI tooling scale.
Every 5 minutes off your CI run is worth more than any autocomplete feature. If your pipeline is 30 minutes, you're serializing your entire organization's output. At a 10-person team with 5 PRs per day, a 20-minute CI run introduces 100 person-minutes of blocked time daily — just waiting. Depot, GitHub Actions caching, Nx Cloud, incremental builds — these are unsexy investments that unlock disproportionate returns.
Automate the review layer, not just the generation layer.
The 91% increase in review time from AI adoption isn't inevitable. It's a design choice. Hooks, linters, automated PR checks, AI-assisted review tools like CodeRabbit — these can shrink the review burden before human eyes ever touch the code. The goal isn't zero human review. It's ensuring that humans review decisions, not mechanics.
Fix specification quality upstream.
The METR study found developers were 19% slower with AI tools on real repositories — projects they knew intimately. The reason: AI doesn't have the contextual understanding of why the code exists, what constraints matter, and what the reviewer will care about. Better specifications — structured requirements, explicit constraints, acceptance criteria before the first line is generated — shrink that gap. The methodology matters more than the model.
These three investments address the 76–84% of time that AI coding tools leave untouched. They're also unglamorous compared to "our AI writes 10,000 lines an hour," which is why most organizations haven't made them.
The Bottom Line
The median developer codes 52 minutes a day. IDC says it's 16% of the job. Forrester says 24%. Microsoft's own engineers say 11%.
Every number tells the same story: coding was never the bottleneck, and optimizing it — even dramatically — can't fix what's actually broken. Amdahl's Law is indifferent to how impressive the demo looks.
The companies seeing real delivery improvement — Stripe, StrongDM, the organizations at the top of DORA's rankings — haven't found a better coding AI. They've fixed the pipeline. They've automated review. They've treated specification as an engineering artifact, not a Slack message.
The productivity ceiling isn't where everyone is looking. It's in the 13 hours your PR waits for review. It's in the 30-minute CI run that serializes 10 engineers. It's in the ambiguous requirement that generates beautiful code solving the wrong problem.
Fix those. Then measure what your coding AI actually contributes.
Related reading: 93% of Developers Use AI. Productivity Gains? About 10%. Here's Why. — the data on why adoption hasn't moved delivery metrics. And At 50% Context, Your AI Starts Cutting Corners — how the way you feed information to your AI changes the output quality.