AI isn't making developers more productive – it's making them busier

Chris Stokel-Walker · article · 2026-06-11 source ↗ Reader 🖥️

Code Was Never the Bottleneck DORA & Engineering Metrics Measuring AI Impact Orchestration Tax / Human Review Bottleneck Professional Identity Pull Requests & Async Code Review

A large-scale study of 100,000+ GitHub developers reframes the AI-coding story as redistribution rather than acceleration: AI makes developers busier by ballooning code output, but net shipped value barely moves because fixed human review/integration capacity is the binding downstream constraint.

practical · expository news writeup of an empirical study — A ~768-word LeadDev news article reporting an NBER working paper (w35275) by MIT and Wharton researchers analyzing 100,000+ GitHub developers, framed for engineering managers with practitioner commentary from Alfonso Graziano (Nearform) and Josh King (&above). It reports and interprets a study rather than conducting its own analysis.

Structure

Part	Role
Framing and study introduction	Sets up the gap between adoption enthusiasm and outcomes, then introduces the NBER/MIT/Wharton study of 100,000+ GitHub developers as a 'reality check': writing code is not the same as shipping code.
The generational productivity ladder at the code level	Reports monotonically rising code-writing activity across three AI-tool generations (autocomplete +40% commits, sync agents +140%, async agents +180%, +741% lines of code).
The attenuation and the weak-link hypothesis	Shows the 741% code increase collapsing to 65% more PRs and only 20% more releases, explained by the 'weak-link hypothesis' and Graziano's Theory-of-Constraints framing (throughput set by the slowest stage; WIP piles up before the human constraint).
The bottleneck reaches the end user	Extends the pipeline logic to market outcomes: new app releases spiked since mid-2025 but total app usage stayed flat, so more AI-assisted software does not equal more value or discovery.
The prescription: developer as evaluator	Josh King's mentality-shift argument — the developer's job has changed from writing code to evaluating it; review is now the primary constraint on delivery, and organizations must adapt review/testing/maintenance to the volume.

Key terms

busier (vs. more productive)
A rise in task-level activity — commits, lines of code, work-in-progress — that does not convert into more delivered/shipped value; effort is redistributed, not reduced.
productivity
Operationalized as a hierarchy of proxies climbing the org: coding activity (commits, LOC) at the base, pull requests in the middle, actual software releases (and ultimately end-user value) at the top; the piece treats releases/value, not commits, as the productivity that matters.
weak-link hypothesis
The study authors' term for why gains attenuate: AI is effective at generating raw code, but everything after (reviewing PRs, integrating changes, managing releases) still depends on largely fixed human effort and judgment, so surplus AI code creates a downstream traffic jam.
the constraint / slowest stage (Theory of Constraints)
Graziano's framing: a system's throughput is set by its slowest stage; speeding up any other stage does not raise throughput — it only grows the pile of work-in-progress in front of the real constraint, and pushing harder makes the system worse.
evaluator of code (vs. writer of code)
King's reframe of the developer role: with agents generating volume, the primary human skill becomes reviewing/judging code rather than producing it; review becomes roughly half the job and the primary constraint on delivery.

Propositions

explicit⚡ disputed & corroboratedAI is making developers busier, not more productive: a large-scale study reframes AI-assisted coding as a redistribution of effort in which task-level output soars while net shipped value barely moves.conf: high
supportsLenny Rachitsky's Post · p4 — Supplies the measured structural mechanism for the Conflicted majority's felt exhaustion: 'exhausted by the work of keeping up' is what it looks like when AI balloons output (+741% code) while fixed human review capacity turns the surplus into growing work-in-progress rather than more shipping.
extends ←AI productivity is burning out your best engineers · p1 — The 'busier not faster' tax localized to mid-level engineers as burnout: the large-N finding that AI redistributes effort rather than reducing it (output soars, shipped value barely moves) is here given a human locus and a human cost -- the surplus lands as invisible validation load on the middle, and the middle burns out.
supports ←Code maintainability plummets in the AI coding era · p6 — Maintainability decay (duplication, un-refactored legacy) is a concrete mechanism/cost behind the 'busier not more productive' redistribution: the surplus AI output isn't just un-shipped, it is actively degrading the codebase across eight quality metrics, so more code buys less net value.
contradicts ←Time Warp: The Gap Between Developers' Ideal vs Actual Workweeks in an AI-Driven Era · p6 — Self-reported survey data here shows daily AI users feeling more productive and satisfied, while the activity-log-based study concludes AI is making developers busier without more real output — a methodology-driven conflict between self-report and telemetry evidence.
supports ←Are You Getting Your Money's Worth from AI? · p15 — Both distinguish raw output/speed from delivered business value, warning that faster activity doesn't guarantee more value shipped.
explicitdevelopedProductivity gains attenuate sharply as work climbs the organizational hierarchy: a 741% increase in lines of code written translates to only a 65% increase in pull requests and just a 20% increase in actual software releases.conf: high
supportsThe Organization Is the Bottleneck · p1 — Large-N empirical backing (741% code -> 65% PRs -> 20% releases across 100,000+ GitHub developers) for the claim that AI makes engineers write code faster but does not obviously make organizations deliver value faster.
extends ←Writing Code vs. Shipping Code: Productivity Effects Across Generations of AI Coding Tools · p2 — This paper is the primary NBER source behind that secondary article's identical headline statistic (741% lines of code / 65% PRs / 20% releases); this extraction supplies the full causal design, robustness checks, and model behind the number that article reports directly.
explicitcorroboratedSuccessive AI-tool generations raised code-writing activity monotonically: early autocomplete (GitHub Copilot) boosted commits by 40%, interactive synchronous agents (e.g. Claude Code) pushed the cumulative gain to 140%, and autonomous asynchronous agents raised it to 180% while increasing lines of code written by 741%.conf: high
supports ←11 Tips For AI Coding With Ralph Wiggum · p9 — Ralph is a concrete practitioner instance of the 'autonomous asynchronous agents' whose code-writing volume that study measures (+180% activity, +741% lines of code): Tip 8 reports the loop piling 'dozens of commits into a repo in hours', corroborating that this tool generation multiplies raw output. (The consequence — that the surplus jams review — is the article's blind spot; see gap g1.)
extends ←Writing Code vs. Shipping Code: Productivity Effects Across Generations of AI Coding Tools · p1 — Primary-source relationship for the tool-generation productivity figures (40%/140%/180%) that the secondary article reports as background.
explicitcorroboratedThe 'weak-link hypothesis' explains the attenuation: AI accelerates raw code generation, but downstream stages (PR review, integration, release management) depend on largely fixed human judgment, so the surplus code creates a traffic jam at the human-review constraint rather than more delivered value.conf: high
supportsAgentic Code Review · p1 — The weak-link hypothesis is the machine-scale, quantified form of 'a single human actually understanding a change is now the constraint the whole pipeline waits on' — surplus AI code jams at the fixed human review/integration stage.
extends ←Writing Code vs. Shipping Code: Productivity Effects Across Generations of AI Coding Tools · p3 — Same primary-source relationship for the 'weak-link hypothesis' explanation: this paper supplies the formal model and the fitted elasticity of substitution (0.25) that the secondary article summarizes in prose.
supports ←AI-Assisted Software Development: Team Profiles and Capabilities for Putting Research into Action · p5 — DORA's own instability-rising finding corroborates the 'weak-link hypothesis' — AI-driven volume increases outrun fixed downstream (review/integration/production-stability) capacity, producing exactly the kind of downstream cost this claim identifies.
explicitcorroboratedThe developer's core skill is shifting from writing code to evaluating it: at one firm concurrent open PRs rose from three or four to 20-plus, making review roughly half the job and the primary constraint on delivery, even as many teams still treat review as a final step.conf: medium
supports ←Addy Osmani’s Post · p4 — The individual-craft prescription (direct, verify, own) for the measured writing→evaluating role shift.
explicitdevelopedThe bottleneck extends to end users: since mid-2025 new app releases spiked moderately across the Apple App Store and Google Play while total app usage stayed flat, so a growing share of AI-assisted apps attracts no meaningful audience — more software shipped does not equal more value or discovery.conf: medium
extends ←Writing Code vs. Shipping Code: Productivity Effects Across Generations of AI Coding Tools · p5 — Primary-source relationship for the app-marketplace 'releases up, usage flat' claim; this extraction adds the four-marketplace detail, the small-audience-share trend, and the paper's own acknowledged inability to distinguish quality from discovery-bottleneck explanations.
implicitCommit, line-of-code and PR counts are being mistaken for productivity: because throughput is set by the slowest (human) stage, the time AI saves upstream is reabsorbed as growing work-in-progress rather than converted into delivered value, so busyness rises while net productivity does not.conf: high
supportsAgentic Code Review · p16 — Corroborates that the binding constraint on shipping is human review confidence, not code-writing speed: activity metrics rise (velocity dashboard green) while net throughput does not move — commits/LOC/PR counts mistaken for productivity.

Arguments

AI makes developers busier but not more productive in net terms. strength: high

Explicit premises:

AI dramatically increases code-writing activity (up to +741% lines of code, +180% coding activity).
That gain attenuates as work moves up the pipeline: only +65% PRs and +20% releases.
Downstream stages (review, integration, release) depend on human judgment whose capacity is largely fixed (the weak-link hypothesis).
A system's throughput is set by its slowest stage, so speeding other stages only grows work-in-progress in front of the constraint (Graziano / Theory of Constraints).

Implicit premises:

Activity metrics (commits, lines of code, PR counts) are being mistaken for productivity, when the productivity that matters is delivered/shipped value.
The time AI saves in code generation is reabsorbed into more downstream tasks and accumulating work-in-progress rather than freed up, so faster code-writing produces more busyness, not more output.

Inferences:

If upstream output multiplies while the binding downstream human constraint stays fixed, the surplus necessarily piles up as WIP rather than converting to throughput.
Therefore observed gains at the keyboard cannot be read as net productivity gains for the organization.

Organizations must reconceive the developer as an evaluator of code and make review the primary constraint they optimize, not the final step. strength: medium