Async agents can flood your repo while you sleep. That part is real. What is also real, and what most vendor decks skip, is what happens after the diff lands.
A May 2026 working paper from researchers at MIT and Wharton follows more than 100,000 GitHub developers from raw lines of code through pull requests, projects, and shipped releases. They also cross-check app marketplaces. The headline is uncomfortable: each generation of AI coding tool widens the gap between code written and software actually delivered.
Direct answer: AI massively accelerates upstream work (typing, commits, PR volume). Downstream work (review, test, merge, release) barely keeps up. The pipeline is only as fast as its slowest human checkpoint. If your review culture was already fragile, agents multiply the pain.
Three generations, one funnel
The paper splits tools into three buckets that match how most teams actually adopt them:
| Generation | Examples | Cumulative effect on commits |
|---|---|---|
| Autocomplete | GitHub Copilot in VS Code | ~40% |
| Sync agents | Claude Code, Cursor, Copilot agent mode | ~140% |
| Async agents | GitHub Coding Agent, OpenAI Codex cloud runs | ~180% |
Autocomplete nudges the keyboard. Sync agents pair with you in the editor or terminal. Async agents take a task and come back with a branch.
Each step up the ladder pushes more bytes through the top of the funnel. That is the number vendors quote in keynotes. It is also only the first stage of a longer chain.
NBER Working Paper 35275 (Demirer, Musolff, Yang)The attenuation effect in plain numbers
Software production is staged. Lines bundle into commits. Commits bundle into pull requests. Pull requests merge into projects. Projects become releases users can install.
The researchers measure each hop. Gains shrink as you climb.
For sync agents alone:
| Stage | Approximate lift |
|---|---|
| Lines of code | +741% |
| Pull requests | +65% |
| Releases | +20% |
Autocomplete shows the same shape at smaller scale: +228% on lines of code, +36% on commits, +10% on releases.
Combine all three generations and commits roughly triple. Projects rise about 50%. Releases rise about 30%. Still meaningful. Nowhere near 741%.
The authors call this the weak-link hypothesis. AI removes friction where machines are already fast. Humans still gate what ships. Elasticity of substitution between AI and human effort lands around 0.25. Strong complementarity, not replacement.
Why async agents make the bottleneck obvious
Async agents cannot click merge for you. A human still owns the release decision. That is by design for most enterprises, and it is exactly where the study finds the stall.
Async adoption raised pull request creation by roughly 72% in the digest's summary of the paper. Releases did not scale with it. Some companies have even stopped accepting public pull requests because the volume of agent-generated diffs exceeded maintainer capacity.
I have seen the same pattern on client repos: agent branches pile up, CI goes green on happy paths, and the senior engineer becomes a serial diff reader. Throughput feels high. Outcomes do not.
The app marketplace paradox
GitHub activity is not the whole story. The researchers also pulled monthly panel data from four marketplaces: Apple App Store, Google Play, Chrome Web Store, and SourceForge.
New app submissions ticked up. Total usage did not. Downloads and ratings stayed flat in the first three months after launch.
That matches the meme cycle: builders shipping apps with zero users. Lowering the cost of writing code does not solve distribution, positioning, or product-market fit. It just makes it cheaper to learn that lesson in public.
What DORA adds: AI as a multiplier, not a fix
The 2025 DORA report on AI-assisted software development surveyed nearly 5,000 tech professionals. AI is near-universal in the sample. Trust is not: most use it, a sizable chunk still does not trust generated code without heavy verification.
DORA's framing matches the NBER math. AI amplifies what you already have. Strong review and test culture gets faster. Weak culture gets noisier PR queues and more rework.
If you are buying agents to paper over missing fundamentals, you are buying a louder version of the same bottleneck.
Methodology worth trusting (and one caveat)
The study uses a matched event design: adopters compared to similarly active developers from the same calendar week one year earlier. That cuts some activity bias.
Data blends public GitHub signals with Microsoft telemetry on AI usage. Marketplace panels validate aggregate patterns.
Timing caveat: code written today may ship weeks later. Async agents only went wide in mid-2025. Some of the release gap could narrow as backlogs clear. The directional pattern (attenuation at each stage) already shows up consistently across tool generations. I would not bet the gap disappears without workflow changes.
What I take from this as a practitioner
- Stop equating LOC with shipped value. Dashboards that track agent output without release cadence will lie to you.
- Budget review capacity like you budget tokens. If PR volume doubles and reviewer hours stay flat, you are not accelerating delivery.
- Treat discard as a skill. When generation is cheap, knowing what not to merge matters as much as knowing what to build.
- Measure merge-to-deploy time, not just commits. GitLab's team calls merge-request cycle time the new bottleneck metric. I agree.
| Metric | What it tells you |
|---|---|
| Commits per week | Agent activity (upstream) |
| Open PR age | Review backlog |
| Release frequency | Actual shipping |
| Post-release defects | Whether speed bought quality |
Where this leaves agent adoption
The NBER paper is not an argument against agents. A 30% lift in releases from combined tool generations would be huge for any workplace technology. It is an argument against extrapolating task-level benchmarks to company-level promises.
Agents changed the cost of drafting code. They did not repeal code review, security review, staging, or the product judgment call at merge time.
If your team is scaling async agents without scaling verification, you are optimizing the wrong stage of the funnel.
I help teams wire agent workflows that survive review, test, and release gates without drowning maintainers. If merge queues are your new bottleneck, book a free discovery call and we can map where your pipeline actually stalls.