# The AI engineering productivity gap: 2026 benchmarks

> Elite AI teams nearly doubled their merge rate in 2026 while developers using no AI stalled. See the engineering productivity gap in LinearB's 2.7M-PR data.

_This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._

Just In!

From measurement to action: moving off Appfire Flow without starting over

[Register now](https://linearb.io/event/flow-migration)

[Resource Center](https://linearb.io/resources)

 / The AI engineering productivity gap: how elite teams pull ahead in 2026

# The AI engineering productivity gap: how elite teams pull ahead in 2026

Elite AI teams nearly doubled their merge rate in 2026 while developers using no AI stalled. See the engineering productivity gap in LinearB's 2.7M-PR data.

[Get the guide](https://linearb.io/resources/ai-engineering-productivity-gap#get-the-guide)

![Cover graphic of The AI engineering productivity gap: how elite teams pull ahead in 2026](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Hero_2026_AI_Benchmarks_2a046cdfdb?_a=BAVMn6ID0)

## Summary

* Developers with very high AI usage merged code at 2.3x their June 2025 rate by May 2026, while developers using no AI held roughly flat.
* AI adoption is shallower than it looks. Elite orgs see 54% of PRs with AI coding assistance and under 5% from autonomous agents.
* Autonomous agents show the weakest results, merging within 30 days at 79%, versus 92% for human-only pull requests.
* AI code review is the fastest available gain, lifting PR yield by up to five percentage points.
* Token cost hits $481 per developer per month at the 90th percentile of spend, still under 4% of a fully loaded developer's cost.

The AI engineering productivity gap is the widening difference in delivery output between engineering teams that use AI heavily and teams that barely use it at all. According to LinearB's 2026 AI benchmarks, drawn from 2.7 million pull requests and 83,000 developers across 253 engineering organizations, developers in the highest AI usage band merged code at 2.3 times their June 2025 rate by May 2026, while developers using no AI merged at roughly the same rate as a year earlier. 

The gap is a correlation, not proof that AI alone drives the result, and it has widened fastest since the start of 2026\. This page breaks down what the data shows, what it costs, why autonomous agents contribute less than the attention around them suggests, and how to close the gap using [an operating model built for the AI era](https://linearb.io/resources/apex-framework).

## What the 2026 data shows about AI and merge rate

Developers who use AI most have widened their delivery lead since the start of 2026\. In LinearB's 2026 AI benchmarks, the very high usage band (AI on 75% or more of coding days) reached 2.3 times its June 2025 merge rate by May 2026, and the high usage band (50% or more of coding days) reached 1.8 times over the same period.

The typical developer in the top band roughly doubled output. Measured as a median against the same developers a year earlier, the very high band improved 95.7%, the high band 65.4%, and the moderate band (20% or more of coding days) 24.4%. Developers using no AI declined 3.6%. The average lift runs higher than the median in every band because a minority of developers with outsized gains pull it up, so the very high band's collective output grew 134% even though the middle developer roughly doubled. The cleanest way to read this is [at the pull request level](https://linearb.io/platform/ai-developer-productivity-insights), where AI activity connects to real delivery outcomes rather than tool adoption counts.

These figures are correlational. They show that heavier AI use tracks with a higher merge rate, not that AI alone produced the change.

![LinearB_AIProductivity_table.png](https://assets.linearb.io/image/upload/v1785376852/Linear_B_AI_Productivity_table_fc0fb03976.png)

What to do next: baseline your team's merge rate against its own output from a year ago, split by how heavily each developer uses AI, so you can see whether your gap is widening or closing.

## Why AI adoption numbers hide the real gap

High adoption does not mean deep AI use. At the top 10% of organizations in LinearB's 2026 AI benchmarks, 54% of pull requests involve AI coding assistance, 45% of merged code lines are written by AI, and fewer than 5% of pull requests come from autonomous agents. If you assumed the leaders produce most of their code with AI, the data reads the other way.

AI code review shows the widest spread of any adoption measure. 57% of pull requests get an [AI code review](https://linearb.io/use-case/optimize-code-review) at the top 10% of organizations, against 26% at the top 30% and 8% at the top 60%. That seven-fold difference between the leaders and the middle is the clearest sign that AI leverage still has room to grow, even among the strongest teams.

| AI adoption benchmark                     | Elite | Good | Fair | Needs focus |
| ----------------------------------------- | ----- | ---- | ---- | ----------- |
| Share of PRs with AI coding assistance    | 54%   | 35%  | 20%  | <20%        |
| Share of PRs with AI code review          | 57%   | 26%  | 8%   | <8%         |
| Share of PRs written by autonomous agents | 4.7%  | 1.1% | 0.1% | <0.1%       |
| Share of merged code lines written by AI  | 45%   | 25%  | 12%  | <12%        |

Elite, good, and fair map to the top 10%, 30%, and 60% of the 253 organizations in the data set.

What to do next: separate adoption from leverage in your own reporting. Track what share of pull requests get AI coding assistance and AI code review, not just how many developers hold a license.

### Download your free copy of the guide

## Autonomous agents are not the shortcut

Autonomous agents contribute less than the attention around them suggests, and the reason is ownership rather than capability. At the top 10% of organizations, 79% of agent-opened pull requests merge within 30 days, against 92% for human-only pull requests. At the top 60%, agentic yield falls to 37%. When an agent opens a pull request that no engineer owns, it tends to sit unmerged, pointing to experimentation at the edges of real work rather than agents operating at scale inside delivery.

AI code review runs the other way. Pull requests with an AI review attached merge at the highest rate of any category, and the lift is largest where teams struggle most, up to five percentage points over the all-PR baseline and up to seven points over human-only pull requests at the top 60% of organizations. Among developers with very high AI usage, PR yield slipped 4.4% year over year even as merge rates climbed, because faster code generation [moves the bottleneck downstream](https://linearb.io/blog/dora-ai-capabilities-model-engineering-efficiency-apex-framework) into review and testing, and yield is the first place that drag shows.

![LinearB_Agents_BarChart.png](https://assets.linearb.io/image/upload/v1785376730/Linear_B_Agents_Bar_Chart_289aa5954e.png)

What to do next: turn on AI code review before you scale autonomous agents. It is the fastest available gain, and it protects yield as AI puts more code in flight.

## What AI costs, and how to tie spend to delivered work

AI token spend is a small share of engineering payroll, but it is climbing fastest at the top. At the 90th percentile of spend, token cost reaches $481 per developer per month, or $35.20 per coding day, under 4% of a fully loaded developer's cost. The heaviest cohort's daily cost rose nearly 75% in three months while the median held roughly flat.

Raw spend means little on its own. Cost matters once you tie it to delivered work, and PR yield, the share of opened pull requests that merge within 30 days, is the connection. In LinearB's 2026 AI benchmarks, the top 10% of organizations convert 90% of the pull requests they open, the top 60% convert 81%, and agentic pull requests at the top 60% convert 37%. Every abandoned pull request is spend with no return.

Cost per delivered pull request puts spend and output in one number. Take a 350-developer organization spending $300,000 a month on tokens and merging 3.3 pull requests per developer per week. As it scales AI investment to $1.2 million a month and merge rate climbs to 5.67 with rework holding at 5%, total engineering cost rises 22%, effective throughput rises 72%, and cost per delivered pull request falls 29%, from $864 to $613\. Matching that throughput with headcount at baseline productivity would take roughly 250 more developers, about $2.7 million a month in payroll against $900,000 a month in AI spend.

![LinearB_WhatAICosts_Linechart.png](https://assets.linearb.io/image/upload/v1785376766/Linear_B_What_AI_Costs_Linechart_92fd1a1522.png)

What to do next: report cost per delivered pull request, not token spend alone, and [build a defensible AI ROI model](https://linearb.io/blog/calculate-ai-roi-dora-value-chain-apex-framework) before your next budget cycle.

### Download your free copy of the guide

## Close the gap with APEX, LinearB's operating model for the AI era

Closing the AI engineering productivity gap takes a consistent operating model, not one more dashboard. APEX is the framework LinearB built on [DORA](https://dora.dev) and the [SPACE framework](https://dl.acm.org/doi/10.1145/3453928) for the AI era. It treats AI as a first-class production contributor and measures four outcomes: AI leverage, predictability, efficiency, and developer experience. The teams pulling ahead run the same four plays.

**Measure AI leverage first.** You cannot close a gap you cannot see. Track what share of pull requests involve AI coding assistance and AI code review, measured against each team's own baseline, so you know where AI is working and where adoption has stalled.

**Find and replicate your halo teams.** Strong AI-driven developers pull their teammates up. Find the teams where a heavy AI user sits next to teammates who are not there yet, then spread the setups, prompts, and workflows on purpose. Replicating your best teams beats hiring your way to the same output.

**Fight the drag that stalls AI-assisted code.** AI-assisted code arrives in bigger pull requests that mature more slowly, and agentic pull requests yield less. Turn on AI code review for the yield gain, automate pull request sizing and review routing, and track rework and PR maturity alongside merge rate.

**Coach with the data, do not rank with it.** The data starts coaching conversations, it does not end careers. Ask a developer who uses AI on 20% of their days what it would take to reach 50%. Sometimes the answer is training, sometimes it is a system you need to fix for them.

What to do next: pick the one play your organization is weakest on and run it this quarter. For most teams that is turning on AI code review.

## AI leverage benchmarks at a glance

| AI leverage benchmark                      | Elite | Good | Fair | Needs focus |
| ------------------------------------------ | ----- | ---- | ---- | ----------- |
| PRs with AI coding assistance              | 54%   | 35%  | 20%  | <20%        |
| PRs with AI code review                    | 57%   | 26%  | 8%   | <8%         |
| PRs written by autonomous agents           | 4.7%  | 1.1% | 0.1% | <0.1%       |
| Merged code lines written by AI            | 45%   | 25%  | 12%  | <12%        |
| PR merge rate (PRs per developer per week) | 2.6   | 1.9  | 1.3  | <1.3        |
| PR yield rate, all PRs                     | 90%   | 86%  | 81%  | <81%        |
| PR yield rate, agentic PRs                 | 79%   | 58%  | 37%  | <37%        |
| Token cost per developer per month         | $481  | $152 | $50  | <$50        |

Elite, good, and fair map to the top 10%, 30%, and 60% of the 253 organizations in the data set. Token figures are directional averages for developers with some AI use. The widest gaps between the leaders and the middle sit in AI code review adoption and agentic PR yield, which is why both rank near the top of the levers to pull.

### Frequently asked questions

**What is the AI engineering productivity gap?**

The AI engineering productivity gap is the widening difference in delivery output between engineering teams that use AI heavily and teams that rarely use it. In LinearB's 2026 AI benchmarks, the highest AI usage band reached 2.3 times its June 2025 merge rate by May 2026, while developers using no AI declined 3.6% over the same period.

**How do you measure AI's impact on engineering productivity?**

Measure AI at the pull request level, against each team's own baseline. Track what share of pull requests involve AI coding assistance and AI code review, then connect that activity to merge rate, PR yield, and cost per delivered pull request rather than to tool adoption counts.

**Do autonomous agents improve engineering output?**

Not yet at scale. At the top 10% of organizations, 79% of agent-opened pull requests merge within 30 days against 92% for human-only pull requests, and agentic yield falls to 37% at the top 60%. The limiting factor is ownership, since an agent-opened pull request that no engineer owns tends to sit unmerged.

**Does AI code review improve merge rates?**

Pull requests with an AI review attached merge at the highest rate of any category in LinearB's 2026 AI benchmarks. AI code review lifts PR yield by up to five percentage points over the all-PR baseline and up to seven points over human-only pull requests at the top 60% of organizations.

**How much does AI coding cost per developer?**

At the 90th percentile of spend, token cost reaches $481 per developer per month, or $35.20 per coding day, under 4% of a fully loaded developer's cost. The top cohort's daily cost rose nearly 75% in three months while the median held roughly flat.

**How do you prove ROI on AI coding tools?**

Report cost per delivered pull request, which combines people cost and AI spend divided by pull requests opened times effective yield. Tying spend to delivered work gives finance a defensible number instead of an adoption chart, and it shows which lever, merge rate, yield, or token efficiency, is doing the work.

## Get on the right side of the gap

You cannot manage what you cannot see, and right now most engineering leaders are guessing. LinearB is the [engineering productivity platform](https://linearb.io/platform/overview) that helps you prove whether AI is improving throughput without giving up delivery confidence, flow efficiency, or developer experience. Track adoption, merge rate lift, and yield for human, AI-assisted, and agentic code on their own baselines. Catch bugs, security risks, and spec mismatches before merge with independent AI code review that lifts PR yield by up to five percentage points. Connect token spend to delivered work with cost and ROI reporting built for the board.

Teams like Expedia and Syngenta already run on LinearB, and Syngenta cut cycle time 81%. See how the APEX framework puts these benchmarks to work.

_Source: LinearB's 2026 AI benchmarks, drawn from 2.7 million pull requests and 83,000 developers across 253 engineering organizations, February through May 2026 (first-party data). Customer proof point: Syngenta, 81% cycle time reduction. Named frameworks: DORA (dora.dev) and SPACE (ACM Queue, 2021)._

Written by Yishai Beeri, CTO at LinearB.

Download your free copy

![Cover of The AI engineering productivity gap: how elite teams pull ahead in 2026](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/2026_AI_Benchmarks_545dcb8e4e?_a=BAVMn6ID0)

## Structured data

_Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._

```json
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "LinearB",
  "url": "https://linearb.io",
  "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg",
  "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.",
  "sameAs": [
    "https://www.linkedin.com/company/linearb"
  ],
  "award": [
    {
      "@type": "Award",
      "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms",
      "dateAwarded": "2026",
      "awardedBy": {
        "@type": "Organization",
        "name": "Gartner®"
      }
    },
    {
      "@type": "Award",
      "name": "Great Place to Work Certification",
      "dateAwarded": "2025-2027",
      "awardedBy": {
        "@type": "Organization",
        "name": "Great Place to Work"
      }
    },
    {
      "@type": "Award",
      "name": "America's Best Startup Employers 2025",
      "dateAwarded": "2025",
      "awardedBy": {
        "@type": "Organization",
        "name": "Forbes Magazine"
      }
    }
  ],
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "SOC 1 Type 2"
    },
    {
      "@type": "Certification",
      "name": "SOC 2 Type 2"
    },
    {
      "@type": "Certification",
      "name": "GDPR Compliance certification"
    },
    {
      "@type": "Certification",
      "name": "ISO 27001"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "The AI engineering productivity gap: how elite teams pull ahead in 2026",
  "description": "Elite AI teams nearly doubled their merge rate in 2026 while developers using no AI stalled. See the engineering productivity gap in LinearB's 2.7M-PR data.",
  "abstract": "Developers with very high AI usage merged code at 2.3x their June 2025 rate by May 2026, while developers using no AI held roughly flat. AI adoption is shallower than it looks. Elite orgs see 54% of PRs with AI coding assistance and under 5% from autonomous agents. Autonomous agents show the weakest results, merging within 30 days at 79%, versus 92% for human-only pull requests. AI code review is the fastest available gain, lifting PR yield by up to five percentage points. Token cost hits $481 per developer per month at the 90th percentile of spend, still under 4% of a fully loaded developer's cost.",
  "url": "https://linearb.io/resources/ai-engineering-productivity-gap",
  "datePublished": "2026-07-30T02:09:46.020Z",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg"
  }
}
```

## More on linearb.io

### Top navigation

- [Book a Demo](https://linearb.io/book-a-demo)
- [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews)
- [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights)
- [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact)
- [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server)
- [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation)
- [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization)
- [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting)
- [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance)
- [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support)
- [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience)
- [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience)
- [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys)
- [Platform overview](https://linearb.io/platform/overview)
- [Register now](https://linearb.io/event/engineering-productivity-gap)
- [Customers](https://linearb.io/customers)
- [Pricing](https://linearb.io/pricing)
- [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb)
- [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework)
- [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq)
- [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security)
- [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy)
- [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts)
- [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources)
- [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops)
- [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report)
- [Blog — Product updates and practical insights](https://linearb.io/blog)
- [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io)
- [API Docs](https://docs.linearb.io/api-overview)
- [Status](https://www.linearbstatus.com/)
- [Integrations](https://linearb.io/integrations)
- [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026)
- [Sign in](https://app.linearb.io/login)
- [What the 2026 data shows about AI and merge rate](https://linearb.io/resources/ai-engineering-productivity-gap#what-the-2026-data-shows-about-ai-and-merge-rate)
- [Why AI adoption numbers hide the real gap](https://linearb.io/resources/ai-engineering-productivity-gap#why-ai-adoption-numbers-hide-the-real-gap)
- [Autonomous agents are not the shortcut](https://linearb.io/resources/ai-engineering-productivity-gap#autonomous-agents-are-not-the-shortcut)
- [What AI costs, and how to tie spend to delivered work](https://linearb.io/resources/ai-engineering-productivity-gap#what-ai-costs-and-how-to-tie-spend-to-delivered-work)
- [Close the gap with APEX, LinearB's operating model for the AI era](https://linearb.io/resources/ai-engineering-productivity-gap#close-the-gap-with-apex-linearbs-operating-model-for-the-ai-era)
- [AI leverage benchmarks at a glance](https://linearb.io/resources/ai-engineering-productivity-gap#ai-leverage-benchmarks-at-a-glance)
- [Get on the right side of the gap](https://linearb.io/resources/ai-engineering-productivity-gap#get-on-the-right-side-of-the-gap)
- [Enterprise](https://linearb.io/solutions/enterprise)
- [Contact](https://linearb.io/contact-us)
- [About us](https://linearb.io/about-us)
- [Careers](https://linearb.io/careers)
- [Service agreement](https://linearb.io/services-agreement)
- [Privacy policy](https://linearb.io/privacy-policy)
- [DPA](https://linearb.io/data-processing-agreement)
- [Security FAQ](https://linearb.io/security-faq)
- [Substack](https://devinterrupted.substack.com/)

### Footer

_Additional links from the site footer, not repeated from the top navigation above._

- [GitHub](https://github.com/linear-b)
- [LinkedIn](https://www.linkedin.com/company/linearb)
- [Twitter](https://twitter.com/LinearB_Inc)