Defining Merge Rate as an AI Coding Quality Signal
Merge rate tracks whether AI code survives review, which acceptance rate misses.

Merge rate is a more honest signal of AI coding quality than suggestion acceptance rate because it measures whether proposed work survives delivery. Read by pull request type, it exposes the gap between AI adoption and code reaching the codebase. Its value is diagnostic. A merged pull request shows that work passed the pipeline while leaving its future soundness uncertain.
Why suggestion acceptance rate is the wrong benchmark for AI coding quality
Accepting a suggestion in an editor feels like a decision about code. It is only a decision to keep a proposal. The developer can delete those lines before committing, abandon the pull request, or close it without merging. Suggestion acceptance rate records the interaction but cannot distinguish any of those outcomes from work that ships.
LinearB's 2026 benchmark makes this distinction clear by separating the suggestion acceptance that vendors report from the share of pull requests that reach the codebase. The vendor metric is easy to collect and correlates with developer satisfaction, which makes it useful for understanding the editing experience. Satisfaction does not establish production impact, however. A vendor-supplied, vendor-incentivized measure centers the moment of acceptance and leaves the fate of the accepted code untracked. A replacement must follow the work through review and merge, where a proposal becomes part of the codebase.
What merge rate actually measures and how it is defined
PR acceptance rate is the share of opened pull requests that are merged within a set window. The benchmark uses a 30-day window and calls this measure acceptance rate. Here, merge rate names the same measure, avoiding confusion with editor suggestions. It is distinct from merge frequency, which counts merges per developer per week. One measures the proportion of proposed work that clears the pipeline, while the other measures the pace of completed merges.
The window gives the proportion a firm boundary. It separates work that is actively progressed and merged from work that sits indefinitely or is quietly closed. The unit is the pull request. A merged PR shows that the work passed code review, CI gates, and merge-queue policy, going beyond the judgment that it looked worth keeping in the editor. The measure tracks when code enters the codebase, so it shows delivery through merge but leaves out what happens to the code in production.
The benchmark classifies PRs into three types before reporting their merge rates. Unassisted PRs are human-authored without AI involvement, while AI-assisted PRs are human-led but substantially shaped by AI. Agentic PRs are created entirely by an AI agent, with no human leading the effort. This classification makes the comparison interpretable. An AI license count describes access to a tool, but these groups connect how work was produced to whether it reached the codebase.
The gap: AI-assisted and agentic PRs merge at a fraction of the rate of human-authored ones
AI-assisted PRs reach the codebase at less than half the rate of unassisted human work. Agentic PRs lag further still. The benchmark documents this gap across pull requests from thousands of engineering teams in dozens of countries, making it the central finding of its comparison. The difference is between the delivery outcomes of work produced with different degrees of AI involvement.
The gap has widened in 2026 as AI-originated PR volume has grown. More proposed work is entering the queue without clearing review. The lowest merge rate belongs to the category with no human leading the effort, a distinction that becomes important when interpreting the result. At aggregate level, the agentic pattern looks more like experimentation at the edges of real work than agents operating at scale inside delivery pipelines. That establishes the disparity, but it does not by itself establish that every unmerged PR contains inferior code.

Why AI PRs consistently merge at lower rates: size, ownership, and what reviewers actually do
The benchmark finds that AI-assisted PRs are roughly two and a half times the size of unassisted ones at the 75th percentile. LinearB's guidance places them above the upper bound of what a reviewer can hold in their head. Larger PRs take longer to pick up because reviewers defer them, and aging PRs accumulate merge conflicts that further impede progress. Chen & Stratton's Harvard working paper, using Jellyfish data, reports PR merge time rising 49% in 2026, a finding separate from the benchmark and consistent with that pressure.
Ownership adds a different obstacle for agentic work. When no engineer leads a PR, nobody is assigned to answer reviewer questions or advocate for its progress through the queue. The proposal can stay open with no one moving it forward. This is a delivery failure even if the code could be made acceptable. This also means the agentic category cannot show on its own how well an agent writes correct code.
The benchmark's survey respondents describe a two-phase breakdown, beginning with hesitation about whether AI-written code can be trusted. Reviewers then shift from close reading to scanning the code. Under time pressure, this is a rational response to the amount of code awaiting attention, but it weakens the scrutiny that review is supposed to provide. The low merge rate therefore does not mean reviewers are reliably finding defects and rejecting the PRs that have them.
TestMu AI's State of AI in Quality Engineering 2026 finds that the vast majority of teams have merged AI-written code or tests they did not fully understand. That finding exposes the other side of review pressure. LinearB also finds that AI predominantly generates new code rather than reusing existing code, interpreting this as a failure to instruct models to reuse what is already present. These PRs are harder to review in the context of the codebase, which adds to the strain on review.
What happens after merge: churn, duplication, and the quality signals merge rate doesn't see
A PR that merges is not necessarily work that holds. The 2026 AI telemetry described in the evidence shows code churn rising sharply where AI use is high, with churn defined as recently merged lines that are deleted or rewritten in the same quarter. This points to code that passed review but proved insufficient in practice. This evidence is separate from the benchmark's merge-rate findings and shows how well the accepted work holds up over time.
GitClear's 2026 Maintainability Gap report shows a sharp rise in within-commit copy/paste, while the amount of code that was moved and properly refactored has fallen sharply over the same period. Its dataset also shows fewer cross-file function calls, an indicator of reuse across the codebase. Code block duplication and error-masking constructs are up. These signals concern the structure left behind by authorship. A pipeline can accept work while the codebase becomes less reusable and harder to maintain.
In the TestMu AI survey, a large share of teams report more escaped defects or production incidents as AI-generated code grew. It also finds that verification remains heavily dependent on human review after code is written, with limited reliance on automated gates before commit. Passing that process is therefore not a complete quality verdict. Merge rate captures survival through the pipeline up to and including merge, while churn, duplication, and defects describe what that survival does not guarantee. The distinction preserves the metric's usefulness without asking it to describe the codebase six weeks later.
The countervailing evidence: where AI PRs outperform the fear
Mergify's 2026 State of Merge Queues finds that AI-assisted PRs break the main branch at a markedly lower rate than non-AI PRs. Its dataset covers more than 200,000 merges across hundreds of engineering teams. This is substantial evidence against a blanket claim that AI-assisted work reaching the codebase is more likely to break it. The result deserves weight equal to the evidence of lower merge rates. Otherwise, a measure of how much proposed work gets through becomes an unsupported judgment about the safety of everything that does.
The report presents the finding as observational. That limitation cuts both ways. The result cannot establish an inherent advantage for AI authorship, but neither can the aggregate merge gap establish an inherent disadvantage in the code that survives review. A compatible interpretation is that review and CI filter out a larger share of candidate work before it reaches the main branch. Under that interpretation, the cost falls on reviewer throughput, with main-branch breakage avoided.
Breaking main, accumulating duplication, and requiring later rewrites are different outcomes, so a favorable result on one can coexist with unfavorable results on another. The studies do not measure interchangeable forms of quality.
The MSR 2026 study of agent-authored PRs further complicates any uniform judgment by finding wide variation in merge rate across agents. Documentation and CI tasks merge most reliably, while bug-fix and performance tasks merge least often. A low overall AI merge rate is partly a quality signal and partly a pipeline-calibration signal. Review infrastructure built for human-authored PRs is not automatically well-calibrated for the volume, size, and ownership patterns of AI-authored work.
What merge rate by PR type reveals that no other single metric does
Merge rate segmented into unassisted, AI-assisted, and agentic PRs connects AI use to delivery outcomes in a way adoption counts and editor acceptance cannot. Cubic's State of AI coding 2026 documents the typical developer roughly doubling merged PRs over the past year and merging substantially more code by volume. That is evidence of greater output, but it does not reveal what share of proposed work failed to reach the codebase. A pipeline can have more completed merges and a falling merge rate when incoming work grows faster than completed work.
The distribution of the gap makes that distinction useful to engineering leaders. An especially low agentic rate points to a need to look at ownership and review infrastructure, while a low AI-assisted rate calls for a look at PR size and reviewer calibration. These are diagnostic leads. Because task type and how well agents perform also vary, these categories help show where to look but cannot prove a single cause. The signal gains precision when the question moves from whether AI is being used to which AI-originated work is reaching the codebase.
For a team evaluating its investment, the practical baseline is its own merge rate by PR type from a year ago, followed by segmentation by AI usage level. That comparison shifts attention from generated volume to the shape of the delivery gap. Its interpretation must still account for the strength of review. The TestMu AI survey finds that only a minority of teams run automated checks on AI-written code before merge, so the signal's integrity depends on a human process already under strain. A higher rate is not automatically an improvement if it reflects weaker scrutiny.
GitClear's report and its CEO's warning about measuring productivity through commit counts or lines added identify the risk of rewarding output while maintainability decays. Merge rate by PR type corrects the earlier accounting error by counting which proposals reached the codebase, while post-merge evidence establishes whether that work endured. A merged PR records the decision to make that work part of the codebase.
Notes
- State of AI coding 2026
Supplied the finding that the typical developer roughly doubled merged PRs over the past year, which the article contrasts with the share of proposed work that merges.
- State of AI in Quality Engineering 2026: 81% merged AI code they didn't fully understand
Provided survey findings on teams merging AI-written code they did not fully understand, more escaped defects, and limited automated checks before merge.
Every new piece from The Rejected PR, as it's published.
Follow