Author’s note: AI agents boosted code line count by 30%, but delivered tickets only grew by 12%. This article uses research data to pinpoint the bottleneck and lays out efficiency steps your team can follow directly.
Many teams introduce AI agents only to find that commit records increase, merge requests increase, yet requirements aren’t delivered much faster. A recent Harvard University study using the Jellyfish platform, covering 718 enterprises, delivered a quantified conclusion: code volume rose 30%, delivery rose only 12%, and the gap is mostly swallowed by downstream stages like code review.
This is not another article bashing AI coding. The study’s conclusion is clear: AI agents genuinely brought output growth — the problem is that the entire delivery pipeline didn’t scale up alongside it. This article will first break down the data, then present a 5-step approach from measurement to process redesign.
Core value: After reading this, you’ll be able to tell where your team’s AI coding efficiency is stuck, and know what to change first and how to measure whether the improvement works.
The Core Takeaways on AI Coding’s Productivity Bottleneck
The study covers data from January 2021 through March 2026, spanning more than 700 companies and 700,000 employees—roughly 300 million work events in total. Sources include HR records, version control systems, ticketing systems, scheduling tools, and usage logs from generative AI tools such as GitHub Copilot, Cursor, and Claude Code. A sample that size is rare in research of this kind.
| Takeaway | Finding | What it means for teams |
|---|---|---|
| Output growth | AI agents drive +30% lines of code, +20% commits, +23% pull requests | Coding really did get faster |
| Delivery growth | Tickets resolved per person per month grew only 12% | Output didn’t convert into delivery at the same rate |
| Time allocation | Engineers spend only 30%–40% of their time writing code | Optimizing coding alone has a low ceiling |
| Review pressure | Review time +49%, comment count +53%, share of pull requests needing rework doubled | The bottleneck shifted to review |
| AI review | After introducing AI-assisted review, the share of people taking part in reviews still rose 14% | Bolting on AI review tools alone doesn’t fix the problem |
How Coding Assistants and AI Agents Differ in Productivity Gains
The study separates two categories of tools. Coding assistants (mostly autocomplete and chat) delivered only modest gains: +12% lines of code, +9% commits, +5% pull requests—and only the growth in commits was statistically significant. More importantly, coding assistants produced no increase in tickets resolved, meaning there was almost no measurable impact on delivery.
AI agents (which can autonomously complete multi-step tasks) showed significant growth across all three output metrics and delivered a 12% increase in tickets. That suggests “letting AI take on a whole task” is more valuable than “letting AI help write a few lines”—but it also means downstream teams receive proportionally more code and a heavier review load. The study specifically notes that the rise in review workload can’t be explained by individual pull requests getting larger; the issue is that the code itself requires more discussion and revision.
Where’s the Bottleneck in AI Coding Productivity? Understanding It Through Theory of Constraints
The throughput of a delivery pipeline is set by its slowest stage. When coding takes up only 30%–40% of an engineer’s time, even doubling coding speed shortens the overall cycle by a third at most—and in practice, that accelerated coding just pushes more work-in-progress into review and testing.
A few numbers from the research piece together the full causal chain: agents write more, so merge requests multiply; comments per merge request rise 53%, meaning reviewers need more effort to understand and question AI-written code; the share of merge requests that need changes doubles, meaning first-pass quality is dropping. All of these costs land on human reviewers—who also happen to be the most experienced and most time-constrained people on the team.
| Stage | What AI changes | Typical symptoms | Priority |
|---|---|---|---|
| Planning and scoping | When requirements are vague, AI “confidently” writes in the wrong direction | Rework, merge requests rejected wholesale | High |
| Coding | Speed improves noticeably | Code volume explodes, individual output looks great | Already optimized |
| Code review | Review backlog and complexity rise together | Reviews queue up, comment threads drag on | Highest |
| Testing | Coverage can’t keep up with new code volume | More regressions | High |
| Deployment and operations | Engineers understand the code less deeply | Slower incident troubleshooting | Medium to long term |
Community discussion backs this up too. One developer commented that “every line of code is a potential risk,” and another pointed out that agents are unreliable collaborators that may pull outrageous moves just to finish a task. Others argue that MTTR (mean time to recovery) will become an important metric for assessing AI’s impact, because the less deeply engineers understand the code they ship, the harder troubleshooting gets.
Getting Started with AI Coding Efficiency: A 5-Step Breakthrough Method
The methods below are ordered from lowest to highest investment, so teams can roll them out in sequence. Each step tries to include measurable metrics, avoiding unverifiable judgments like “it feels faster.”
Step 1: Establish a Delivery Baseline for AI Coding Efficiency
Don’t rush to switch tools — build your measurement system first. The research was able to spot the gap because it looked at both output metrics and delivery metrics. Many teams look only at lines of code and commit counts, and end up mistakenly believing their efficiency gains were a big success.
I’d suggest tracking two sets of metrics at the same time: on the output side, look at commit counts and merge request counts; on the delivery side, look at tickets closed per person per month and the cycle time from requirement start to launch. Then add the three review-side metrics: average merge request review time, comments per merge request, and the rework rate. This data can usually be exported directly from Git platforms and ticketing systems like Jira.
| Metric Category | Specific Metrics | Data Source | What to Watch |
|---|---|---|---|
| Output | Commit count, merge request count | Git platform | For reference only, not for performance review |
| Delivery | Tickets closed per person per month, requirement cycle time | Ticketing system | Core target metrics |
| Review | Review time, comment count, rework rate | Git platform | Bottleneck early warning |
| Quality | Online incident count, MTTR | Monitoring and incident records | Long-term health |
Step 2: Front-load requirements planning for your AI coding agent
Agents are most likely to “confidently go off the rails” when requirements are vague. Rather than tearing apart an entire merge request at review time, spend ten minutes before the work starts to spell out the task clearly: which modules to change, which interfaces must not be touched, what the acceptance criteria are, and which tests need to be added.
A practical approach is to have the agent produce an implementation plan first, then let an engineer confirm it before moving into coding. Changes cost far less at the planning stage than at the code stage, and reviewers get to know the scope of change up front. This step may look like it adds time at the front end, but it directly reduces problems like “the share of merge requests needing rework doubles.”
Step 3: Control the granularity of merge requests containing AI-generated code
Reviewers’ attention is a limited resource. Even if research shows the rising review burden isn’t entirely because individual merge requests got bigger, controlling granularity is still the most direct way to reduce cognitive load. Set clear boundaries for agent tasks: one merge request solves one problem, and refactors are submitted separately from feature changes.
At the same time, require the agent to state in the merge request description the motivation for the change, the scope of impact, and the self-test results. Reviewers can then judge risk just by reading the description, instead of reverse-engineering intent from hundreds of lines of diff — and the back-and-forth in comments drops noticeably.
🎯 Technical tip: Models differ noticeably in task decomposition and plan quality. APIYI apiyi.com provides API access to the mainstream models covered in this article, such as Claude and GPT, and is compatible with both the OpenAI and Anthropic API formats. Teams can switch models within the same agent workflow and compare which one produces merge requests with a lower rework rate. For setup details, see the APIYI documentation at docs.apiyi.com.
Step 4: Hand Tests and Self-Checks to the Agent, Not the Reviewer
Research found that after introducing AI-assisted review, the share of team members participating in reviews still increased by 14%. That tells us bolting an AI onto the review stage isn’t enough — the more effective move is to shift the quality gate earlier: let the agent complete unit test additions, run tests locally, run static checks, and format code before submitting.
You can make “tests pass, checks pass” a hard precondition for opening a merge request, with CI enforcing it automatically. Reviewers can then focus on design soundness, edge cases, and business logic instead of pointing out null pointers and naming issues. AI review tools work well as a first filter, but the final judgment should still come from someone who understands the business.
Step 5: Tiered Review and AI Coding Risk Stratification
Not all AI-generated code needs the same intensity of review. You can tier changes by risk: docs, tests, and boilerplate go through lightweight review; business logic goes through standard review; changes touching authentication, payments, data migration, or concurrency must get deep review from senior engineers, and the author must be able to explain every change clearly.
| Risk Level | Change Type | Review Method | Suggested Number of Reviewers |
|---|---|---|---|
| Low | Docs, test cases, boilerplate | AI first pass + quick human confirmation | 1 |
| Medium | Standard business logic | Full human review | 1–2 |
| High | Authentication, payments, data migration, concurrency | Deep review by senior engineers + author walkthrough | 2 or more |
Finally, bring MTTR into long-term tracking. If engineers’ understanding of the code keeps getting shallower, the problems will surface during production incidents. Periodically asking authors to explain the AI code they merged is a low-cost way to prevent “nobody actually understands this code.”
🚀 Quick start: If you’re building an in-house coding agent for your team, you can first apply for test credits at APIYI apiyi.com, then use the same task description to call different models separately, record the review time and rework rate for the generated merge requests, and decide on your primary model from there.
Model Selection Reference for AI Coding Agents
Model selection alone won’t solve workflow bottlenecks, but it does affect the quality of the first submission, and in turn the review burden. The table below offers directional guidance based on workflow roles. For actual results, rely on your team’s own testing.
| Workflow Role | Capability Focus | Selection Approach | Available Platforms |
|---|---|---|---|
| Implementation plan generation | Long-context understanding, task breakdown | Choose flagship models with stronger reasoning capabilities | APIYI apiyi.com, official API |
| Code writing and refactoring | Code quality, adherence to constraints | Choose models that perform well on coding benchmarks | APIYI apiyi.com, official API |
| Test supplementation and self-check | Stable, high call volume | Choose more cost-effective models | APIYI apiyi.com, official API |
| AI initial review | Finding common defects | Use a different model from the one that wrote the code to avoid same-source blind spots | APIYI apiyi.com, official API |
💰 Cost note: Agent workflows have high call volumes, and the billing dimensions (input, output, and cache-hit unit prices) directly determine cost. This article doesn’t list specific prices. For all model prices and billing methods, refer to the real-time data on APIYI’s pricing page at docs.apiyi.com/models.
Common FAQ
Q1: What does “AI coding increases code volume by 30% but delivery only by 12%” mean?
This comes from Harvard research using Jellyfish data: after adopting AI agents, lines of code grew 30%, but tickets resolved per engineer per month grew only 12%. The gap mostly comes from downstream stages — code review, testing, and the like — becoming the new bottleneck.
Q2: How big is the productivity difference between AI coding assistants and AI agents?
Coding assistants show smaller output gains — only commit records, up 9%, are statistically significant — and they don’t increase the number of tickets resolved. AI agents, on the other hand, grow lines of code, commits, and merge requests by 30%, 20%, and 23% respectively, and drive a 12% increase in tickets.
Q3: Is the data in this AI coding productivity study trustworthy?
The data spans January 2021 to March 2026, covering more than 700 companies, 700,000 employees, and roughly 300 million work events. The time-allocation estimates were also validated through a survey of 100 engineers, so both the sample size and the cross-validation are fairly solid.
Q4: Can adopting AI code review tools solve the review bottleneck?
Not on its own. The research shows that after introducing AI-assisted review, the share of people participating in review still rose by 14%. A more effective approach is to move testing and self-checks earlier, before submission, and pair that with tiered review so human reviewers can focus on high-risk changes.
Q5: How can I cheaply test how different models affect review workload?
We recommend comparing several models on the same batch of real tasks:
1. Sign up at APIYI apiyi.com and get test credits
2. Follow the APIYI docs at docs.apiyi.com to connect your existing agent using the OpenAI- or Anthropic-compatible format
3. Record, per model, the review time, comment count, and rework rate for the merge requests it generates
That way you pick models based on data rather than impressions.
Q6: How do I estimate the cost of AI coding agents for my team?
First measure the average input and output tokens consumed per task, then multiply by the model’s unit price and your monthly task volume. Agent tasks often carry very long context, so cache hits significantly affect cost. For exact unit prices and how caching is billed, refer to the APIYI pricing page at docs.apiyi.com/models.
Q7: What are the long-term risks of AI coding productivity gains?
The main risk is that engineers develop a shallower understanding of the code. The community view is that when a codebase keeps expanding while understanding lags, failures may become more frequent and harder to troubleshoot. We recommend tracking mean time to recovery over the long term, and requiring authors to be able to explain the AI-written code they merge.
AI Coding Productivity: Key Takeaways
- Output doesn’t equal delivery: AI agents drive code volume up 30%, but delivery tickets only climb 12%
- Coding accounts for just 30–40% of the time: optimizing only code writing puts a low ceiling on overall gains
- Review is the number one bottleneck: review time +49%, comments +53%, and rework rates double
- AI review isn’t a silver bullet: even after adopting it, the share of people participating in reviews still rises 14%
- Shift quality gates upstream: planning upfront, small commits, and pre-commit self-checks are the most effective moves
- Keep an eye on MTTR long-term: prevent teams from “writing more AI code while understanding less of it”
- Choose models with data: compare rework rates across models through the APIYI apiyi.com unified interface
Summary
Research has already answered where AI coding productivity gets stuck:
- The bottleneck has moved: once coding speeds up, code review, testing, and planning become the new rate limiters
- Measure in pairs: output metrics must be tracked alongside delivery, review, and quality metrics
- Changing the process matters more than swapping tools: planning upfront, controlling granularity, shifting self-checks forward, and tiered review—tackle them in that order
Real productivity gains aren’t about getting AI to write more code—they’re about getting less code to pass review with higher first-time quality. Start by running one iteration cycle to establish baseline data, then roll out the 5-step method above step by step.
If you need to compare how different models perform inside an agent workflow, I recommend validating quickly through APIYI apiyi.com. The platform is compatible with both the OpenAI and Anthropic interface formats, and pricing is listed at docs.apiyi.com/models.
📚 References
- InfoQ China: AI-Generated Code Is Bottlenecked by Downstream Stages — Chinese version of the research write-up
- Link:
infoq.cn/article/c3vTLNrRwfCzw8SAmz90 -
Notes: covers the research methodology, key data, and community discussion
-
InfoQ English original: Jellyfish AI Productivity — English version of the research write-up
- Link:
infoq.com/news/2026/10/jellyfish-ai-productivity -
Notes: handy if you want to check the original English wording
-
APIYI Documentation Center — model access and API reference
- Link:
docs.apiyi.com -
Notes: how to connect using the OpenAI- and Anthropic-compatible formats
-
APIYI Model Pricing page — billing rules for each model
- Link:
docs.apiyi.com/models - Notes: input, output, and cached-token unit prices all follow the live data on this page
Author: APIYI Technical Team
Technical discussion: Feel free to reach us through the APIYI homepage at apiyi.com — more integration docs are available in the docs.apiyi.com documentation center
