AI Writes Code 7x Faster. Shipping It Is the New Bottleneck.

Every engineering team has felt it over the past two years: code appears faster than ever, and somehow nothing reaches users any sooner. A new working paper from the National Bureau of Economic Research (NBER), the nonprofit that publishes much of the economics research later cited in policy and the press, finally put numbers on that feeling, and the numbers are stark.

Demirer, Musolff and Yang tracked more than 100,000 GitHub developers alongside their AI-usage telemetry, across three generations of tooling: autocomplete, interactive agents, and autonomous agents. The deeper you follow the work down the delivery pipeline, the more the gains disappear.

741% more code, 10% more shipped

Autonomous coding agents drove a 741% increase in lines of code and a 65% increase in pull requests. Commits rose 180%. Then the curve falls off a cliff: projects grew about 50%, and actual releases just 30%, dropping to roughly 10% at the individual-developer level.

That last comparison is the whole story. Seven times more code written. Barely a tenth more software actually shipped.

The authors are direct about why. The upstream gains are "attenuated by human bottlenecks in the production chain": integrating changes across files, reviewing and merging pull requests, and managing releases. They estimate an elasticity of substitution of just 0.25 between AI output and human effort, which in plain language means AI and humans are strong complements, not substitutes. The model writes ten times more code. Humans still have to integrate it, review it, secure it, deploy it, and keep it running.

There's a second finding worth sitting with. Across four of the largest app marketplaces, the number of new apps rose, but total usage did not increase at all. More software got built. None of it moved the needle on what people actually use. Building was never the moat. Shipping something reliable enough to keep, and keeping it up, always was.

The cost center moved

When one stage of a pipeline gets ten times faster and the next stage doesn't, the slow stage becomes the entire cost. Economists call it the weak link. Anyone who has watched a finished feature sit in a release queue for two weeks calls it Tuesday.

So the expensive part of software development quietly relocated. It used to live in writing code. Now it lives in everything between "it works on my machine" and "users are reliably using it in production":

• Integration across a codebase the AI changed faster than any human reviewed it
• Review and merge, now the real throughput ceiling, with 65% more pull requests competing for the same human attention
• Release management: environments, secrets, rollbacks
• Deployment, security patching, updates, backups, and monitoring
• Keeping it all running at 3am, long after the agent that wrote it dropped out of the context window

None of that is writing code. All of it is shipping code. And it is exactly the work that does not get faster just because the diff arrived sooner.

This is the work Elestio does

We built Elestio around a bet we made well before this paper existed: that the binding constraint in modern software would move downstream, into operations. Fully managed deployment, security, updates, backups, monitoring, and support, on dedicated VMs rather than shared infrastructure, so the slow stage stops being slow.

The NBER data is the clearest outside validation we've seen. If your developers are now producing several times the code and shipping only a fraction more of it, the leak isn't in your IDE. It's in the gap between commit and production. That gap is precisely what we operate, so your team can spend its finite review capacity on logic and architecture, the parts the paper proves are genuinely complementary to AI, instead of on pipelines, patching, and pager duty.

When the AI can ship, too

There's one more shift that makes this moment different from a year ago. The same AI agents generating all that code can now drive the deployment step directly. Elestio exposes an MCP connector, so an assistant like Claude can provision a production-grade, fully managed service on Elestio as part of the same conversation where the code was written.

Ask the agent to stand up a Postgres database, a Redis cache, an n8n instance, or any of 400+ open-source services, and it can do it through the connector, with backups, SSL, updates, and monitoring already wired in. The deployment isn't a fragile script the agent improvised and then forgot. It's a managed service that keeps running after the chat window closes.

That closes the loop the paper exposes. AI handles the writing. The MCP connector lets AI also trigger the shipping. And Elestio carries the part neither the model nor your developers should be spending nights on: keeping the thing alive, patched, and backed up in production.

The teams that win the next two years

AI handed every team a firehose of code. The winners won't be the ones generating the most of it. They'll be the ones who closed the distance between writing and shipping, and who refused to let their most expensive human hours drain into infrastructure toil.

You can point your AI workflow at managed infrastructure today and let the boring, critical part be handled. Browse the Elestio catalog or wire up the MCP connector and let your agents deploy straight onto infrastructure that someone else keeps running.

Thanks for reading ❤️ See you in the next one 👋

Source: Mert Demirer, Leon Musolff, Liyuan Yang, "Writing Code vs. Shipping Code: Productivity Effects Across Generations of AI Coding Tools," NBER Working Paper No. 35275, May 2026.