# AI in software development: what the 2026 data shows

> AI in software development raised code output without raising delivery. See 8.1M pull requests of evidence on size, review wait, acceptance, and governance.

_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)._


```json
{
  "@type": "FAQPage",
  "@context": "https://schema.org",
  "mainEntity": [
    {
      "name": "What is AI in software development?",
      "@type": "Question",
      "acceptedAnswer": {
        "text": "AI in software development is the use of AI assistants and autonomous agents to write, review, test, and ship code. It divides into agentic pull requests created by agents, AI-assisted pull requests that a developer authors and owns with AI help, and unassisted pull requests written without substantial AI involvement.",
        "@type": "Answer"
      }
    },
    {
      "name": "How much of software development uses AI in 2026?",
      "@type": "Question",
      "acceptedAnswer": {
        "text": "88.3% of surveyed organizations use AI-assisted tools daily or a few times a week, according to LinearB's 2026 Software Engineering Benchmarks Report, against a 71.6% baseline in early 2024. Daily use accounts for 64.9% and use a few times a week accounts for 23.4%.",
        "@type": "Answer"
      }
    },
    {
      "name": "Does AI-generated code get merged as reliably as human code?",
      "@type": "Question",
      "acceptedAnswer": {
        "text": "No. AI pull requests merge within 30 days 32.7% of the time against 84.4% for unassisted pull requests, according to LinearB's 2026 Software Engineering Benchmarks Report. Reaching the elite tier takes above 95% acceptance for manual pull requests against just above 71% for AI pull requests, and the gap holds across every tier.",
        "@type": "Answer"
      }
    },
    {
      "name": "How do you measure the ROI of AI coding tools?",
      "@type": "Question",
      "acceptedAnswer": {
        "text": "Baseline cycle time by phase, pull request size, acceptance rate, and rework rate before expanding adoption, then segment every pull request by contribution type and compare delivery outcomes across the segments. Editor-level metrics such as suggestions accepted describe usage rather than delivered value.",
        "@type": "Answer"
      }
    },
    {
      "name": "Why do AI pull requests take longer to get reviewed?",
      "@type": "Question",
      "acceptedAnswer": {
        "text": "AI pull requests are larger and their ownership is less clear, so they wait longer for someone to pick them up. Agentic pull requests wait 17.6 hours at the 75th percentile against 3.4 hours for unassisted work, and agentic flows are frequently pointed at low-priority backlog items that carry no reviewer expectation.",
        "@type": "Answer"
      }
    },
    {
      "name": "Should AI-generated code go through a different review process?",
      "@type": "Question",
      "acceptedAnswer": {
        "text": "Yes, in two respects. Route agent-created pull requests to a named owner so they do not sit unclaimed, and apply automated review that checks for security risks, bugs, performance issues, and specification mismatches before a human reviewer starts. Calibrate expectations by tool, since acceptance patterns differ between agents.",
        "@type": "Answer"
      }
    }
  ]
}
```

Just In!

The great software factory debate: How do you know it’s working?

[Register now](https://linearb.io/event/the-great-software-factory-debate-2)

```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://linearb.io/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Library",
      "item": "https://linearb.io/library"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "AI in software development",
      "item": "https://linearb.io/library/ai-in-software-development"
    }
  ]
}
```

[Home](https://linearb.io/)

/

[Library](https://linearb.io/library)

/

AI in software development

[View all](https://linearb.io/library/ai-in-software-development/archive)

# AI in software development: what the 2026 data shows

AI in software development raised code output without raising delivery. See 8.1M pull requests of evidence on size, review wait, acceptance, and governance.

![Cover graphic for AI in software development: what the 2026 data shows](https://assets.linearb.io/image/upload/c_limit,w_3840/f_auto/q_auto/v1/library_9_ea64132c4e?_a=BAVMn6ID0)

## Summary

* 88.3% of surveyed organizations use AI-assisted tools daily or weekly, up from 71.6% in early 2024, per LinearB's 2026 Benchmarks Report.
* AI agent pull requests wait 17.6 hours before review versus 3.4 hours for unassisted work, a 5.25x gap, then review faster once picked up.
* AI pull requests merge within 30 days 32.7% of the time versus 84.4% for unassisted work; elite acceptance tops 95% for manual PRs, 71% for AI PRs.
* 44.7% of organizations don't formally measure AI's impact, yet 76.1% of leaders report productivity gains based on adoption signals, not delivery data.

## AI in software development: what the 2026 data shows

AI in software development is the use of AI tools and autonomous agents to write, review, and ship code across the development lifecycle, and in 2026 it splits into two patterns that behave differently. IDE assistants shape code a developer still owns, while agents open pull requests on their own. LinearB's 2026 Software Engineering Benchmarks Report, built from more than 8.1 million pull requests from 4,800 teams and 163,820 contributors across 42 countries, found that AI pull requests merge within 30 days 32.7% of the time against 84.4% for unassisted pull requests. Adoption is close to universal, and delivery has not followed it. This page sets out what the data shows, why the constraint moved to review, and how to measure the impact.

Every relationship on this page is correlational and aligns with LinearB's qualitative research over the past year, so read it as a pattern to test against your own pipeline. For the metric definitions behind the analysis, see [how to measure generative AI code](https://linearb.io/blog/AI-metrics-how-to-measure-gen-ai-code).

> AI in software development is the use of AI assistants and autonomous agents to produce, review, and release code. Measured at the pull request level, it separates into agentic, AI-assisted, and unassisted contributions, and the three behave differently enough that merging them into one number hides the effect.

## Three contribution types, not one category

AI contributions divide into three distinct pull request types, and the distinction is the foundation of every measurement that follows. Agentic AI pull requests are created by agents such as Devin, Copilot Coding Agent, or OpenAI Codex, where the agent interprets a task, generates code, commits, and opens the pull request. AI-assisted pull requests are human-authored and shaped by AI, with the developer keeping control and ownership. Unassisted pull requests are authored by developers without substantial AI involvement.

Treating the three as one category produces averages that describe none of them. The table shows how far apart they sit on the metrics that decide whether code ships.

| Pull request type | Median size (lines) | P75 size (lines) | Pickup Time P75 (hours) | Review Time P75 (hours) |
| ----------------- | ------------------- | ---------------- | ----------------------- | ----------------------- |
| Agentic AI        | 89                  | 293              | 17.6                    | 6.4                     |
| AI-Assisted       | 96                  | 408              | 8.3                     | 3.2                     |
| Unassisted        | 26                  | 157              | 3.4                     | 4.2                     |

Two patterns stand out in the table. AI-assisted pull requests are the largest of the three at the 75th percentile, ahead of fully agentic ones. And review time inverts the pickup order, with AI-assisted pull requests clearing review in 3.2 hours against 4.2 hours for unassisted work, so the largest changes receive the least review time. For the agentic pattern in depth, see [how agentic AI disrupts the software delivery lifecycle](https://linearb.io/blog/how-agentic-ai-will-disrupt-your-software-delivery-lifecycle).

**What to do next:** Tag pull requests by contribution type in your reporting before you draw any conclusion about AI impact. A blended AI number cannot distinguish an ownership problem from a review-depth problem.

## Output rose, acceptance fell

Acceptance rate is the metric that separates code produced from code delivered, and it measures the share of pull requests merged within 30 days of creation. Manual pull requests merge at 84.4% against 32.7% for AI pull requests, which the 2026 report describes as over 2x lower. The gap holds across every performance tier. Reaching the elite tier takes an acceptance rate above 95% for manual pull requests, while AI pull requests reach elite at just above 71%, and exceeding 60% acceptance for AI pull requests is difficult for the teams in the data set.

Three drivers appear behind the gap: ownership of agent-created work is unclear, agentic flows are frequently pointed at low-priority backlog items, and reviewers hesitate on larger or more complex AI changes. Volume of adoption does not close it. Organizations further along in agentic adoption do not show higher acceptance rates, with one outlier running Devin at high adoption and acceptance near parity with manual work, which the report frames as possible rather than typical.

Tool choice changes the picture too. Manual pull request acceptance holds steady around 80% to 82% month over month, while acceptance for agent-created work moves by tool, with Devin improving from April and Copilot declining from May. Calibrating review expectations tool by tool is a more accurate approach than setting one policy for all AI output.

**What to do next:** Report acceptance rate next to adoption rate in the same view. Adoption alone will show a rising line while delivery stays flat.

## Why the bottleneck moved to review

Faster code generation moved the constraint downstream into review and release rather than removing it. The pickup pattern shows where it landed, with agentic pull requests waiting 17.6 hours against 3.4 hours for unassisted work. Reviewer confidence explains part of the hesitation. In LinearB's 2026 AI in Engineering Leadership Survey, 39.4% of respondents are somewhat confident in AI-generated code quality, 33% are neither confident nor unconfident, 19.1% are somewhat unconfident, and 6.4% are extremely confident.

The kind of work AI produces adds to the review load. Refactor rate at the 75th percentile runs 0.37 for unassisted pull requests, 0.22 for AI-assisted, and 0.17 for agentic pull requests, so human-authored work touches existing code at more than 1.5x the rate of either AI category. AI output skews toward new code paths, which means more surface area entering the codebase and less consolidation of what is already there.

Commit hygiene runs the other way. AI-assisted commits touch 4.2 files on average against 7.51 for unassisted commits, at a similar 65 to 66 lines per file, so AI tools hold tighter commit boundaries than developers do. The review problem is one of volume and context rather than sloppiness. For the practice side, see [AI code review](https://linearb.io/blog/ai-code-review).

**What to do next:** Measure pickup time by contribution type this sprint. If agentic pull requests wait longest, change routing and ownership rules rather than asking reviewers to move faster.

## APEX AI leverage: measure AI impact in four steps

AI leverage is the first pillar of APEX, LinearB's operating model for engineering productivity, and its north star metric is AI-assisted pull requests. Measuring at the pull request level is what connects AI activity to code that shipped, which tool-native dashboards reporting suggestions and acceptance clicks cannot do. The full model is in [the APEX framework](https://linearb.io/resources/apex-framework).

1. Baseline before you expand. Capture cycle time by phase, pull request size, acceptance rate, and rework rate while your current adoption level holds steady.
2. Segment every pull request by contribution type, keeping agentic, AI-assisted, and unassisted separate in every report you produce.
3. Attribute delivery outcomes rather than activity. Compare acceptance rate, pickup time, and review time across the three types instead of counting suggestions accepted in the editor.
4. Govern the code path with policy that runs automatically, including review routing, AI code review on every pull request, and merge rules that apply to agent-created work.

Step one is the step teams skip, and it is the reason 44.7% of organizations have no formal measurement of AI's impact while 76.1% of leaders report gains. Without a pre-adoption baseline, a productivity claim rests on sentiment. For the measurement model in detail, see [the AI measurement framework](https://linearb.io/blog/ai-measurement-framework), and for the tool-level ROI question, see [is GitHub Copilot worth it](https://linearb.io/blog/is-github-copilot-worth-it).

**What to do next:** Pick one team and one repository, baseline the four metrics this week, then hold the tool mix steady for a full sprint before you change anything.

## What blocks teams from getting value

Foundations rather than talent are the limiting factor in the 2026 data. Data readiness draws the highest negative response in the readiness matrix, with 15.6% of respondents strongly disagreeing that their internal data is high-quality, well-documented, and accessible for AI workflows, the highest strongly negative response in the readiness matrix. Adding somewhat disagree at 26% and neutral at 22.9% brings the total to 64.5% who indicate their data is not ready.

Policy is the second gap, and it is polarized, with 30.5% of leaders strongly agreeing they have a clear and well-communicated AI usage policy against 21.1% strongly disagreeing. Practice maturity is stronger elsewhere, with 72.6% reporting maturity in user-focused development, 67.4% in iterative delivery habits, and 56.2% in version control maturity. The [2025 DORA State of AI-assisted Software Development report](https://dora.dev/dora-report-2025/) reaches a compatible conclusion, finding that AI amplifies the capability an organization already has, and its companion [AI capabilities model](https://dora.dev/ai/capabilities-model/report/) sets out the seven capabilities that amplify the benefit.

**What to do next:** Publish one page that states where AI may and may not be used, who owns agent-created pull requests, and what review those pull requests require. Policy clarity is cheaper than data cleanup and moves faster.

## Frequently asked questions

### What is AI in software development?

AI in software development is the use of AI assistants and autonomous agents to write, review, test, and ship code. It divides into agentic pull requests created by agents, AI-assisted pull requests that a developer authors and owns with AI help, and unassisted pull requests written without substantial AI involvement.

### How much of software development uses AI in 2026?

88.3% of surveyed organizations use AI-assisted tools daily or a few times a week, according to LinearB's 2026 Software Engineering Benchmarks Report, against a 71.6% baseline in early 2024\. Daily use accounts for 64.9% and use a few times a week accounts for 23.4%.

### Does AI-generated code get merged as reliably as human code?

No. AI pull requests merge within 30 days 32.7% of the time against 84.4% for unassisted pull requests, according to LinearB's 2026 Software Engineering Benchmarks Report. Reaching the elite tier takes above 95% acceptance for manual pull requests against just above 71% for AI pull requests, and the gap holds across every tier.

### How do you measure the ROI of AI coding tools?

Baseline cycle time by phase, pull request size, acceptance rate, and rework rate before expanding adoption, then segment every pull request by contribution type and compare delivery outcomes across the segments. Editor-level metrics such as suggestions accepted describe usage rather than delivered value.

### Why do AI pull requests take longer to get reviewed?

AI pull requests are larger and their ownership is less clear, so they wait longer for someone to pick them up. Agentic pull requests wait 17.6 hours at the 75th percentile against 3.4 hours for unassisted work, and agentic flows are frequently pointed at low-priority backlog items that carry no reviewer expectation.

### Should AI-generated code go through a different review process?

Yes, in two respects. Route agent-created pull requests to a named owner so they do not sit unclaimed, and apply automated review that checks for security risks, bugs, performance issues, and specification mismatches before a human reviewer starts. Calibrate expectations by tool, since acceptance patterns differ between agents.

## Book a demo

Stop managing developer productivity with incomplete data. Start leading with the full picture.

Measure your engineering team’s health and boost productivity.

Track the impact of AI on your delivery pipelines.

Allocate your team resources based on business priorities.

Automate workflows and improve your developer experience.

Accurately forecast and deliver your projects on time.

## 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"
    }
  ]
}
```

## 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/the-great-software-factory-debate-2)
- [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 Library](https://linearb.io/library)
- [Engineering metrics](https://linearb.io/library/engineering-metrics)
- [Platform engineering](https://linearb.io/library/platform-engineering)
- [Engineering glossary](https://linearb.io/library/engineering-glossary)
- [Developer productivity](https://linearb.io/library/developer-productivity)
- [AI in software development](https://linearb.io/library/ai-in-software-development)
- [Engineering management](https://linearb.io/library/engineering-management)
- [Developer experience](https://linearb.io/library/developer-experience)
- [DevOps](https://linearb.io/library/devops)
- [Engineering operations and the context layer](https://linearb.io/library/engineering-operations)
- [Engineering efficiency](https://linearb.io/library/engineering-efficiency)
- [Software delivery](https://linearb.io/library/software-delivery)
- [Research and data](https://linearb.io/library/engineering-benchmarks-and-research)
- [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)
- [AI in software development: what the 2026 data shows](https://linearb.io/library/ai-in-software-development#ai-in-software-development-what-the-2026-data-shows)
- [Three contribution types, not one category](https://linearb.io/library/ai-in-software-development#three-contribution-types-not-one-category)
- [Output rose, acceptance fell](https://linearb.io/library/ai-in-software-development#output-rose-acceptance-fell)
- [Why the bottleneck moved to review](https://linearb.io/library/ai-in-software-development#why-the-bottleneck-moved-to-review)
- [APEX AI leverage: measure AI impact in four steps](https://linearb.io/library/ai-in-software-development#apex-ai-leverage-measure-ai-impact-in-four-steps)
- [What blocks teams from getting value](https://linearb.io/library/ai-in-software-development#what-blocks-teams-from-getting-value)
- [Frequently asked questions](https://linearb.io/library/ai-in-software-development#frequently-asked-questions)
- [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)