Written by: Mark Hull, Co-Founder and CEO, Exceeds AI | Last updated: July 18, 2026
Key Takeaways
- Cursor AI adoption produced measurable short-term PR velocity gains, with studies showing 39%–60% increases in merged PRs for daily users.
- Reviewer bottlenecks offset many of these gains, with median PR review times rising 441% and review queues growing faster than throughput.
- AI-generated code carries elevated technical debt risk, with 24% of introduced issues unresolved after 30–90 days and 1.8–2.5× higher code turnover rates.
- Teams need commit-level AI attribution and 30-day longitudinal tracking to separate genuine productivity from velocity inflation.
- Exceeds AI provides the provenance layer that captures AI authorship at the line level and turns these metrics into a live dashboard, so teams can start a free pilot with real data.
How This Report Builds the Evidence Base
This report synthesizes findings from seven categories of evidence published between mid-2024 and July 2026.
- Randomized controlled trials, including the METR 2025 RCT of 16 experienced open-source developers completing 246 real tasks and the GitHub/Accenture RCT of 4,800 developers
- Large-scale telemetry studies, including arXiv:2607.01904, a longitudinal study of 802 developers and 196,212 pull requests from January 2024 to April 2026
- Observational cohort analyses from Faros AI, GetDX, LinearB, and Swarmia covering tens of thousands of developers
- Difference-in-differences studies of Cursor-adopting GitHub repositories, including He et al. (2026) analyzing 806 Cursor-adopting repositories versus 1,380 matched controls
- Enterprise case studies from Salesforce, Atlassian, Agoda, and Jellyfish
- Code-quality audits from GitClear, CodeRabbit, and the MSR 2026 Mining Challenge
- Internal commit and PR telemetry with 30-day longitudinal outcome windows
Where studies report conflicting figures, this report highlights the methodological differences. The 30-day longitudinal window serves as the minimum threshold for separating short-term velocity from sustainable throughput, because rising code churn at day 30 reliably predicts incident rate jumps by day 90 in AI-assisted codebases.
Key Findings
Short-Term PR Velocity Gains Are Real but Unevenly Distributed
The headline figure most cited in 2025–2026 literature is a 39% increase in merged PRs, drawn from a University of Chicago 2025 observational study that found a 39% increase in merged PRs after Cursor became the default tool, with no increase in revert rate. That figure represents a median outcome. The distribution is wide, and CircleCI’s 2026 report found average throughput up 59% but main-branch throughput for the median team declined 7%, while elite teams showed much larger gains.
At the upper bound, the arXiv:2607.01904 enterprise field study documented per-capita throughput reaching 2.09× the pre-mandate baseline after the organization mandated AI coding tools. The authors described this as a “near-ideal, unusually favorable” environment and cautioned that the reported gains represent an upper bound rather than an industry average.
Reviewer Bottleneck Is the Primary Countervailing Force
Faros AI’s 2026 Engineering Report, based on two years of telemetry from 22,000 developers and 4,000+ teams, found median PR review time up 441.5%. This dataset is the most comprehensive reviewer-load view available for 2025–2026.
ByteIota’s 2026 benchmark research found that code review bottlenecks can offset a substantial portion of the productivity gains from AI coding tools. See how Exceeds AI tracks reviewer load in real time.
The following sections examine each of these patterns in greater depth and provide the specific data points and methodological context behind the summary findings above.
Detailed Findings
Short-Term Velocity: What the Data Shows
iBuidl Research’s March 2026 analysis of engineering teams found productivity improvements from Cursor AI use. The gap between top-quartile and median outcomes is explained primarily by whether teams adapted their review processes to AI-generated code volumes.
Anthropic’s August 2025 internal study of engineers using Claude Code found PRs merged per engineer per day increased after rollout. This figure is notable because it comes from a controlled internal environment with strong engineering culture, not a general enterprise sample.
Cursor-adopting open-source projects experienced substantial increases in lines added during the first adoption month, with velocity gains dissipating over time, according to the He et al. (2026) difference-in-differences study of repositories.
Reviewer Load: The Structural Shift
In the arXiv:2607.01904 enterprise study, human review coverage fell as automated review increased. Total PR cycle time in the same study rose after AI adoption.
30-Day Incident and Rework Rates
Code Turnover Rate for AI-generated code is typically 1.8–2.5× higher than for human-written code, with teams exceeding a 2.0× AI-to-human turnover ratio showing prompt quality or review process problems.
Tool-Interaction Patterns
The He et al. (2026) study found increases in static analysis warnings and code complexity post-adoption in matched GitHub projects, with accumulated technical debt potentially reducing future development velocity.
Interpretation
The evidence from 2025–2026 supports a consistent pattern. AI coding tools including Cursor produce genuine short-term PR velocity gains, but those gains are partially or fully offset by reviewer bottlenecks, and they carry latent technical debt risk that surfaces after 30 days. Faros AI’s breakdown of 2025 DORA data found that individual velocity metrics rose with AI adoption, yet team-level productivity gains show zero correlation to the four core DORA metrics at the organizational level.
The governance implication is direct. Metadata dashboards that report merged-PR counts or cycle time without commit-level AI attribution cannot distinguish sustainable throughput from velocity inflation. Teams without automated review see a 32% AI code survival rate at 90 days, while teams with quality gates achieve 78% survival, and rates below 60% indicate AI tools create more work than they save.
For review process design, the data points toward three interventions with documented evidence. These interventions are smaller PR size discipline, distributed review load, and automated quality gates. Jellyfish’s experiment with 18 engineers using Cursor Bugbot showed that after enabling AI code review, developers reduced average PR size by 82% (from 1,481 to 268 lines), enabling smaller, more reviewable units that increased throughput without increasing total work volume.
For technical debt management, the critical insight is that AI-generated code that passes review is not the same as AI-generated code that survives in production. AI-generated code passes review more easily due to surface quality, such as formatting, syntax, and comments, while issues like architectural misalignment are harder to catch during review and drive higher long-term churn. Detecting this pattern requires longitudinal tracking anchored to commit-level AI attribution, not point-in-time PR metadata. Start tracking AI code outcomes with Exceeds AI.
These general patterns mask significant variation across different organizational contexts. Understanding where your team sits within the distribution of outcomes is essential for setting realistic expectations.
Variations and Nuance Across Teams and Codebases
Outcomes vary substantially by team size, codebase maturity, and multi-tool environment. In the arXiv:2607.01904 study, productivity gains were consistent across developer seniority levels and concentrated in newly written code.
Multi-tool environments introduce an additional measurement gap. Most telemetry studies track a single tool’s contribution. When engineers use Cursor for feature work, Claude Code for refactoring, and GitHub Copilot for autocomplete within the same sprint, no single vendor’s analytics captures aggregate AI impact. GetDX Research’s 14-month study across 400+ organizations measured actual PR throughput gains from AI coding tools at a median of 7.76%, a figure that likely underestimates true AI contribution in multi-tool environments where attribution is incomplete.
Stunzer Digital’s testing across 30+ client projects found greenfield work 35–50% faster with AI coding assistants, active feature development on known codebases 20–30% faster, maintenance and bug fixing on legacy code 10–15% faster, sometimes negative, and code review plus architecture work roughly flat. Task type is a stronger predictor of AI velocity gain than team size alone.
Practical Takeaways for Engineering Leaders
The evidence presented above points to a clear conclusion. Engineering leaders evaluating Cursor AI’s impact on PR velocity need a measurement framework that goes beyond merged-PR counts. Without commit-level attribution and longitudinal tracking, teams cannot distinguish genuine productivity from velocity inflation. The following scorecard questions turn the evidence into actionable evaluation criteria.
PR Velocity Scorecard: Evaluation Questions
- Is merged-PR volume segmented by AI-attributed versus human-authored commits, or are all PRs counted identically?
- Is reviewer load, measured as lines under review per reviewer per week, tracked as a leading indicator alongside PR throughput?
- Is code turnover rate measured at 30 days for AI-attributed code separately from human-authored code?
- Is change failure rate segmented by commit origin, AI versus human, on a 90-day rolling window?
- Are post-merge incident rates for AI-touched code tracked longitudinally, not just at merge time?
- Is PR size discipline enforced consistently for AI-generated diffs, with automated checks for PRs exceeding 400 lines?
Review Guardrail Checklist
- Automated pre-review linting and static analysis applied equally to AI-generated and human-written code before human review begins
- PR descriptions required to include AI tool used, interaction mode, such as agent, edit, or ask, and any known limitations of the generated output
- Reviewer rotation policies updated to account for increased per-PR cognitive load from AI-generated diffs
- Quality gates configured to flag PRs where AI-attributed lines exceed a defined threshold in security-sensitive or load-bearing modules
- Thirty-day and 90-day rework rate targets defined for AI-attributed code, with intervention triggers when ratios exceed 2.0× the human baseline
Platforms that operate on metadata alone, such as PR cycle time, commit volume, and review latency, cannot populate this scorecard. Commit-level AI attribution, captured at the moment of authorship rather than inferred from heuristics after the fact, is the prerequisite for answering these questions with evidence rather than estimation. Exceeds AI’s provenance layer, Exceeds Ink, captures AI authorship across Cursor, Claude Code, Codex, GitHub Copilot, and Windsurf at the line level, writing a portable attestation alongside every commit as a Git Note. That attribution feeds longitudinal outcome tracking, including 30-day rework rates, incident correlation, and code turnover, so the scorecard above becomes a live dashboard rather than a quarterly manual exercise. Turn your scorecard into a live dashboard with Exceeds AI.
FAQ
Does Cursor AI improve PR velocity for all team sizes and seniority levels?
The evidence is mixed and context-dependent. Short-term merged-PR gains are documented across seniority levels, but the magnitude varies significantly. Management-tier engineers and those working in newer codebases tend to see larger gains than individual contributors working in legacy systems. Teams with strong review cultures and existing quality gate infrastructure convert AI velocity gains into durable throughput improvements. Teams without those foundations often see gains offset by reviewer bottlenecks and rework within 30–90 days. The METR randomized controlled trial found that experienced open-source developers were 19% slower with early-2025 AI tools on real tasks, despite perceiving themselves to be 20% faster, which underscores the need to measure outcomes rather than rely on developer self-report.
How do I distinguish real PR velocity gains from false positives caused by AI-inflated output?
Three signals reliably separate genuine throughput from inflated metrics. First, code turnover rate at 30 days. If AI-attributed code is being rewritten or deleted at more than 1.5× the rate of human-authored code, the velocity gain is partially illusory. Second, change failure rate segmented by commit origin. Rising change failure rate on AI-attributed commits while human-attributed change failure rate holds steady indicates quality degradation hidden by surface-level review. Third, reviewer load per reviewer. If review queue depth grows faster than PR volume, reviewers are rubber-stamping rather than genuinely evaluating AI-generated diffs. All three signals require commit-level AI attribution, and metadata dashboards that report aggregate PR counts cannot surface these distinctions.
What is the typical timeline for technical debt from AI-generated code to become visible?
The research consistently points to a 30–90 day window. Code complexity and static analysis warning increases are detectable within weeks of adoption. Incident rate increases and rework spikes typically surface between 30 and 90 days post-merge, particularly for AI-generated code that passed initial review due to surface-level formatting quality but contained architectural misalignments or optimistic error handling. The MSR 2026 Mining Challenge found that 24% of technical debt introduced by AI-generated commits remained unresolved in production after several months. Organizations that track only immediate post-merge metrics, such as cycle time, merge rate, and first-pass review rate, will miss this accumulation until it manifests as production incidents or sprint-over-sprint velocity degradation.
Can AI code review tools solve the reviewer bottleneck without adding governance risk?
AI code review tools reduce first-review latency and catch surface-level issues, but they do not eliminate the need for human judgment on architecture, business logic, and security accountability. Atlassian reduced median PR-to-merge cycle time by 45% after deploying its internal AI code review agent as the automated first reviewer on every pull request. Jellyfish’s experiment showed that pairing AI code review with smaller PR size discipline produced durable throughput gains. The same evidence base shows that 31% of PRs in high-AI-adoption environments are merging with zero human review, not by policy, but because reviewers cannot keep pace with volume. AI code review tools address the symptom. The underlying governance requirement is knowing which lines are AI-generated, in which interaction mode, and what their 30-day outcome history looks like. That requirement calls for commit-level provenance, not just automated review comments.
How should engineering leaders report Cursor AI ROI to executives and boards?
Board-ready AI ROI reporting requires three components that metadata dashboards cannot supply. First, attribution that shows which specific PRs and commits contain AI-generated code, and from which tool. Second, outcome correlation that shows whether AI-attributed PRs have lower or higher incident rates, rework rates, and change failure rates than human-authored PRs over a 30–90 day window. Third, cost alignment that reports token spend per shipped outcome, not per seat. Without commit-level attribution anchored to a provenance layer, leaders are reporting adoption statistics, such as percentage of developers using Cursor, acceptance rates, and merged-PR counts, rather than ROI. The distinction matters because a McKinsey 2026 report found that 77% of enterprises cannot reliably measure AI coding tool ROI, and Forrester’s 2026 Predictions report found that fewer than one in three AI decision-makers can tie AI value to P&L changes. The gap comes from the absence of code-level data.
Neutral Summary
The 2025–2026 evidence on Cursor AI’s impact on PR velocity converges on several durable conclusions. Short-term merged-PR gains are real, with the 39% increase documented in the University of Chicago study representing a median outcome across the evidence base. The 2.09× upper bound from the arXiv study represents near-ideal conditions, and GetDX’s cohort data shows daily AI users merging 60% more PRs than non-users. These gains are not uniformly distributed. Top-quartile teams achieve multiples of what median teams achieve, and legacy codebases show substantially smaller gains than newer repositories.
The reviewer bottleneck is the primary structural countervailing force. The 441% review time increase documented by Faros AI offsets much of the throughput gain. LinearB’s 8.1-million-PR dataset shows a 39-point gap between perceived and measured end-to-end delivery speed. ByteIota’s benchmarks indicate unmanaged review bottlenecks eliminate up to 40% of AI productivity gains.
The 30-day outcome picture introduces additional complexity. Code turnover for AI-generated code runs 1.8–2.5× higher than for human-authored code, and the unresolved technical debt rate documented in the MSR Mining Challenge indicates long-term quality concerns. The He et al. (2026) difference-in-differences study found that Cursor adoption produces a persistent 41% increase in code complexity that compounds over time.
For 2026 decision-making, the practical implication is clear. PR velocity metrics without commit-level AI attribution and 30-day longitudinal outcome tracking are insufficient for proving sustainable ROI. The measurement gap is not a feature limitation of existing analytics platforms, but a category gap. Platforms built on metadata cannot distinguish AI-attributed from human-authored code, cannot track whether AI-touched lines survive or require rework, and cannot correlate token spend with shipped outcomes. Closing that gap is the prerequisite for converting Cursor AI’s documented short-term velocity gains into board-ready proof of durable engineering ROI.