Harvard economists Fiona Chen and James Stratton document a pattern every coding-agent team is living: agents write far more code, but software output and employment barely move because review cannot keep pace. Their job-market paper Artificial Intelligence in the Firm: Bottlenecks in Software Production (November 2026) uses Jellyfish analytics on 445 million work events for 720,542 workers at 655 firms from January 2021 through August 2026. After AI coding agent adoption, coding productivity rises about 73.7%, yet time from pull request submission to approval rises about 56.1%, change requests spike, and resolved Jira issues grow only modestly. If you run Claude Code, Codex, or Cursor on production repos, treat review and verification as the production gate—not token output.
| Question | Answer |
|---|---|
| Am I affected? | Yes if agents already open more PRs per engineer than reviewers can absorb |
| Is there a fix? | No product patch—add evidence before merge (CI, verify skills, scoped reviewers) and metrics on review latency |
| Does data leave my machine? | The study used firm telemetry (GitHub, Jira, calendar); your fix is local policy and CI, not a cloud monitor |
| Security angle? | Interviewed teams tied outages to AI-generated commits and added senior-approval rules |
What the Jellyfish data actually measures
Chen and Stratton combine version control (commits, pull requests), Jira issues and epics marked deployed, calendar time allocation where available, and firm-level adoption timing for tools including GitHub Copilot, Cursor, and Claude Code (per the paper’s data appendix descriptions). Identification is a staggered difference-in-differences design: early adopters are compared with firms that had not yet adopted, under the authors’ argument that procurement and security-review timelines plausibly randomize adoption order conditional on firm size controls.
The paper separates AI coding assistants from AI coding agents—interactive copilots versus more autonomous harnesses. Both raise intermediate coding metrics. For agents, the authors report large increases in lines of code, commits, and pull requests opened—about 35.7% more pull requests per worker-month in their agent estimates (36.0% for commits), alongside a 73.7% coding-productivity gain in the calibrated model. Those are inputs, not shipped features.
Final output is measured as Jira issues and epics resolved when code reaches production. Agent effects on issues are positive but modest (about 13.7% on issues and 18.0% on epics in their agent estimates, with issues borderline significant). The authors use LLM labeling and supervised models on issue text to check whether work items simply grew larger; they do not find a shift in predicted task size that would explain flat issue counts.
That gap—much more code, little more shipped work—is the headline for security-minded agent operators: velocity at the keyboard does not equal velocity through your controls.
How the bottleneck shows up in review
The mechanism is explicit in the paper’s production model: faster drafting sends more code into review, and agents may also lower draft quality entering review, which increases effort per pull request and lowers review productivity. Empirically, after agent adoption:
- Submission-to-approval time rises about 56.1%.
- Backlog wait before the first human comment rises about 59.9%; active review time rises about 58.5% once a reviewer starts.
- Formal change requests rise about 38.5% relative to a 2.77% baseline share (marginally insignificant in DiD); comments per pull request rise about 38.6%—and median pre/post firm comparisons show comments per PR up about 57% after agent adoption.
- Firms reallocate labor toward review in the calibrated model: coding labor share falls about 22.7% (14.9 percentage points from 65.7%) while review labor rises about 43.4% (14.9 pp from 34.3%).
AI code review tools do not erase the queue. 79.1% of firms had adopted them by the sample end, but AI-generated review comments remain a minority of total comments in the data—humans still carry most of the load.
Outages, senior approval, and security policy
Qualitative interviews anchor the quantitative story. One junior engineer quoted in the paper describes a single senior approver who could review only once a week, then notes: after outages caused by AI-generated commits, new rules required senior engineer approval for AI-generated code, creating additional bottlenecks. That is not abstract economics—it is incident-driven access control applied to agent output.
For readers who already run Claude Code verification loops or Surge-style sudo L7 review rubrics, the Harvard result is the organizational mirror: teams that cannot automate judgment respond with narrower approval paths, which back up the queue faster when agents multiply diffs.
The paper also notes that researchers inferred agent use from repository metadata—bot accounts, Co-authored-by trailers, and similar signatures. Information governance teams should expect agent provenance fields in git history to become records subject to retention and legal hold, the same way CI logs already are.
Corroboration: writing code versus shipping code
Independent evidence points the same direction. Demirer, Musolff, and Yang’s NBER working paper Writing Code vs. Shipping Code studies 500,000+ GitHub developers with AI telemetry. Autonomous agents raise cumulative commits about 240%, but releases rise only about 30%. The authors attribute attenuation to human weak links—review, quality control, release capacity—with complementarity between AI and human effort (estimated substitution elasticity 0.23).
The two papers use different data and methods; they are not duplicates. Together they answer a search question many teams ask after adopting agents: why does CI still feel slow when the model is fast? Because the constraint moved to merge and ship, not typing.
What the structural model predicts
Beyond reduced-form estimates, Chen and Stratton calibrate a firm production model with separate coding and review labor inputs. If review productivity stays fixed while coding automation accelerates, their long-run simulations show output leveling near 57.8% above the pre-AI baseline by 2031 while the review labor share hits its ceiling. If review productivity keeps pace with coding productivity, the same model projects output up to about 341% by 2031—with employment paths diverging sharply in that optimistic branch versus roughly 10% lower employment when review stays the weak link.
You do not need to accept every simulation parameter to take the policy lesson: buying more agents without investing in review capacity, verification automation, or narrower change surfaces reproduces the flat shipped-output pattern in the data. Security and platform leaders sit on that investment decision because bad merges and dependency drift show up first as incidents, not as economist charts.
What this means if you run AI coding agents
Chen and Stratton are not prescribing a vendor stack. For local agent harnesses, the actionable translation is measure the same stages they measure:
- Pull requests opened per engineer-week versus median hours to first review and to merge.
- Change-request rate and revert or hotfix rate on PRs tagged as agent-assisted (use commit metadata consistently).
- Issues/epics deployed per sprint—not lines added—as the outcome KPI for security and platform teams.
- Reviewer load: imputed review labor share in the structural model (rises 14.9 percentage points from a 34.3% baseline when agents bind).
- Post-incident rules: document when you add mandatory senior review or path-based CODEOWNERS after agent-related outages—those rules become part of your threat model.
Practical gates that align with the data—not “more AI review bots” alone:
- Repo verify skills and default-branch review policies that agents cannot edit on their branch (Anthropic’s pattern).
- CI required checks on agent-heavy repos, including supply-chain diffs when agents touch
package.json,pyproject.toml, or workflows—see Microsoft’s agent-framework PyPI stealer for why dependency bumps deserve human eyes. - Starsling-style workflow skills when agents edit GitHub Actions (secure Actions skill).
If your organization tracks AI incidents, Recorded Future’s 103-incident coding-tool thread is the parallel external-attacker story; the Harvard paper is the internal process story. Both say the foothold is developer tooling with wide reach—here, unreviewed volume.
What Beam can and cannot do here
Beam is local observability for supported coding agents: PreToolUse hooks (Claude Code and Codex) can deny risky tool proposals when workspace policy is in enforce mode, heuristically scan skills and MCP configs before load, and redact secrets before events are stored on disk.
That helps after an agent proposes a destructive command or pulls a risky skill—but it does not:
- Score pull request quality or enforce CODEOWNERS.
- Run your test matrix or prove a feature works.
- Shorten human review queues or replace senior approval policies.
Observe mode is the honest starting point when you are calibrating new review rules after agent adoption: see what agents attempted before you tighten denies. Limits remain: heuristic scanning, not semantic malware analysis; hook coverage is harness-specific; missing cached policy is fail-open.
Product context: /#watches and coding assistant security.
What developers are saying
Hacker News discussion on the ComplexDiscovery summary (thread) mixes econometrics skepticism with practitioner agreement:
- judahmeek pointed readers to Chen’s primary PDF, noting earlier HN posts used a weaker aggregator title.
- thom argued the root issue is low-quality drafts, not review as an abstract stage—teams that merge without review would simply shift failures to SRE time.
- jacobgorm raised a longer-run worry: if engineers stop reading code, fewer people remain qualified to review, pushing teams toward dropping review or prompt–agent ping-pong replacing coder–reviewer dialogue.
- root_axis summarized the cynical fix—“let AI review and merge”—which the Jellyfish statistics suggest did not clear queues where adopted.
None of those comments replace the paper’s estimates, but they explain why security teams feel political pressure to either automate merge or throttle agents after incidents.
Frequently asked questions
See front-matter FAQ entries for peer-review status, employment effects, NBER corroboration, and Beam limits. The questions mirror searches such as ai code review and how to review AI generated code: the short answer is measure review latency and change-request rate, add non-gameable verification, and keep humans on authorship metadata and dependency diffs.
Related reading
- Claude Code verification loops
- Surge sudo L7 staff-engineer benchmark
- Recorded Future 103 AI-linked incidents
- Microsoft agent-framework PyPI credential stealer
- What agent monitoring software tracks
- Monitor vs block for coding agents
Primary sources: Chen & Stratton, Artificial Intelligence in the Firm (PDF) · Fiona Chen research page · Demirer, Musolff & Yang, NBER w35275
Estimates and sample windows follow the November 14, 2026 paper version. Beam is a local prototype; confirm harness and policy behavior on your installed agent builds.

