Autonomous AI Coding Agents Raise Commits 240%, but Software Releases Rise Just 30%, NBER Study Finds

A working paper revised this month by three economists puts a number on something many engineering teams have suspected but rarely measured: AI coding tools are writing far more code than they are shipping. Using telemetry from more than 500,000 GitHub developers, Mert Demirer, Leon Musolff and Liyuan Yang find that autonomous coding agents raise commit activity by 240% relative to non-adopters, but the same developers ship only 30% more actual releases. The paper, posted by the National Bureau of Economic Research as Working Paper No. 35275, was first issued in May 2026 and revised in September 2026.

Three generations of tools, one production pipeline

The study separates AI coding tools into three generations and tracks the same developers before and after adoption in a matched event-study design: autocomplete tools that suggest code inline, interactive agents that write and edit code alongside a developer in real time, and autonomous agents that take a task description and work independently toward a pull request. Each generation is more capable than the last, and each produces a larger jump in raw coding activity.

What the paper adds is a look past the commit. The authors follow the same cohorts through the rest of the development pipeline — from commits to number of active projects to the software that actually reaches a release tag — and the picture changes at every step.

The numbers

The paper's headline table shows the cumulative effect of each tool generation on commits, and how much of that effect survives by the time work reaches a release:

The number of distinct projects a developer works on rises by 80% for autonomous-agent adopters, according to the paper — already a steep drop from the 240% commit effect. By the time output is counted in shipped releases, the gain falls to 30%, the same order of magnitude as the effect from autocomplete tools on commits alone.

Where the gains disappear

Demirer, Musolff and Yang call this a weak-link problem. Writing code is only one stage in a chain that also includes code review, integration, testing, security checks, deployment and operating the result in production. AI agents accelerate the first stage sharply; they do far less for the stages after it, which still depend on human reviewers, test infrastructure and release processes that were not built to absorb a multi-fold increase in throughput.

The paper estimates the elasticity of substitution between AI and human effort at 0.23, which the authors read as evidence of strong complementarity rather than substitution: AI effort and human effort are not interchangeable inputs in this setting, so adding more of one without the other yields diminishing returns further down the pipeline.

Checking it against app marketplaces

To see whether the commit-to-release pattern holds outside GitHub's own metadata, the authors examined activity across four major software marketplaces. They find a sharp rise in the number of new apps published, consistent with agents lowering the cost of starting new software projects, but no corresponding rise in total usage — engagement with each new cohort of apps was flat or declining in its first months even as the supply of new listings grew. The authors' own summary of the results for CEPR's VoxEU frames this as evidence that task-level AI productivity gains have, so far, translated only partially into software that is actually shipped and used.

An earlier, independent read

An earlier version of the paper, covered by InfoWorld's Matt Asay in June 2026, drew a similar conclusion from a smaller sample of roughly 100,000 developers: raw coding output was climbing far faster than anything that reached users. Asay's independent take was that the finding restates a familiar lesson for engineering organizations — that the demanding part of shipping software was never the typing, but the review, documentation, testing and trust-building that surround it, none of which autocomplete or agentic tools were built to do.

The revised paper's larger sample and larger measured effects sharpen rather than reverse that reading. For organizations weighing where to invest as agentic coding tools spread, the paper's own list of candidate interventions is telling: review-agent triage, smaller change sets, contract testing, modular architecture and protected reviewer capacity — all aimed at the stages after the commit, not at the commit itself.