# Your software factory needs a context layer | LinearB Blog

> Data from 2.7 million pull requests across 253 engineering organizations shows a widening gap between developers using AI deeply and everyone else. An adoption dashboard can't tell you which side your team is on. Here's what a context layer has to see to answer it.

_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
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://linearb.io/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://linearb.io/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Your software factory needs a context layer",
      "item": "https://linearb.io/blog/software-factory-2026-ai-benchmarks-code-review-roi"
    }
  ]
}
```

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

/

[Blog](https://linearb.io/blog)

/

Your software factory needs a context layer

# Your software factory needs a context layer

![Photo of Andrew Zigler](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Headshot3_d7231cbda7?_a=BAVMn6ID0)

By [Andrew Zigler](https://linearb.io/blog/software-factory-2026-ai-benchmarks-code-review-roi#andrew-zigler)

|

August 4, 2026

![unnamed_4_b35455ae7a](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/unnamed_4_b35455ae7a?_a=BAVMn6ID0)

**The software factory got real this year**

You're building a software factory, or your roadmap points at one. Agents triage, spec, implement, review, and ship; your engineers pull back to the edges. How will you know it works?

The people furthest along disagree about what you'll find. Simon Willison[ wrote up StrongDM's factory](https://simonwillison.net/2026/Feb/7/software-factory/) in February, a three-engineer AI team whose code humans neither write nor review. Ona has been[ building one in public](https://ona.com/stories/building-a-software-factory-in-public) and publishing what breaks. Zach Lloyd, Warp's CEO,[ published a build guide](https://www.linkedin.com/pulse/how-build-cloud-software-factory-self-improving-code-zach-lloyd-jizbc/) for the cloud software factory and puts around 30% of issues in scope for one today; he argues your job is shifting from building the product to building the machine that builds it. Dex Horthy of HumanLayer[ ran his company's work through a factory](https://github.com/humanlayer/advanced-context-engineering-for-coding-agents/blob/main/wsff.md) with the humans at the edges, then shut it down after roughly three months of codebase rot. Nothing in how models are trained rewards keeping a codebase maintainable, so quality ended up eroding in a way no test could catch.

If your roadmap points anywhere near this territory, the useful question is which side of a widening gap your team lands on, and your adoption numbers won't answer it.

## **What 83k developers have to show for their AI adoption**

Before you weigh anyone's factory story against your own, look at a larger sample. [LinearB's 2026 mid-year AI benchmarks](https://linearb.io/resources/ai-engineering-productivity-gap) cover 2.7 million pull requests, 7.5 million commits, and 83,000 developers across 253 engineering organizations for the first half of 2026\. The organizations in the sample measure AI impact with LinearB, and the headline comparison tracks the _same_ developers a year apart.

Adoption is shallower than the noise suggests. At elite organizations:

* 54% of pull requests are AI-assisted
* 13% of developers use AI on at least 75% of their working days
* agents author up to 4.7% of PRs, which is the factory's actual share of the work

If your team isn't wall-to-wall agentic yet, you're still in the majority. That 4.7% is the factory, measured. Even up in the 90th percentile, the autonomous part of the pipeline opens only 1 in 20 PRs. Everything else still comes into existence in collaboration with a human.

![image.png](https://assets.linearb.io/image/upload/v1785881295/image_62bbb6cc53.png)

_Depth_ of that adoption is where the sample starts to diverge:

* Developers in the top usage band merged 95.7% more than the same developers did a year earlier.
* The high band gained 65.4% more PR yield, the moderate band gained less than half at 24.4%, and light adopters experienced a meager 2.2% boost. Developers using no AI fell 3.6%.

None of these numbers exist without attribution at the PR level, driving the importance of the context layer in actually seeing all of this activity. If your own factory cannot reflect and answer that question in real time through context, abstracting the process into an autonomous factory will never be durable enough.

## **Agents are not the shortcut, and the reason is human**

The tempting response to a depth gap is to buy autonomy and skip the humans. The merge yield data argues against it. Pull requests merge within 30 days:

* 90% of the time in elite organizations
* 86% for the good tier
* 81% at fair

If you filter by agentic PR merge rates, those same cohorts merge at 79%, 58%, and 37%. Elite organizations have a higher agentic merge rate, meaning more of their agent-led PRs end up being merged. But the fair cohort experiences a significant bottleneck, barely shipping a third of their agentic code.

At that level, most agentic pull requests never merge. Much of this comes down to ownership in the process. When an agent opens a pull request, No human owns it, and it’s easy for it to get lost or languish. That’s a context failure more than anything, because those organizations lack [AI code review](https://linearb.io/platform/ai-code-reviews) to perform initial steps or even handle safe merges, which reduces the cognitive burden for human developers.

A factory without these conveyor belts will lack the routing processes needed to deliver work at scale.

So if your agentic merge rate looks like the fair tier, adding more agents is the wrong purchase. Fix ownership first. Give every agent-opened PR a named human owner before you scale the fleet, even if the fix is as unglamorous as putting agent PRs on the same board as human ones and counting the shepherding as delivery when review season comes.

The fastest win in this category is . It lifts PR yield by up to 5% over the all-PR baseline, and by up to 7% over human-only PRs at the fair tier. Treat AI code review as a station in your factory rather than a feature you switch on. It is the cheapest instrument you can add to a pipeline that already produces more code than your reviewers can absorb, and it’s the one place where the yield curve bends without hiring anyone.

## **Measure what the factory delivered, not what it generated**

You can already see what AI costs you, and you can see how much code it generates. Neither number says whether the factory works. Knowing takes a context layer, a system under the factory that holds the state of your SDLC, feeds it to your agents, and reads back what they cost and what merged. The three measures it returns run on data you already have.

* **Effective PRs are merged pull requests with rework discounted out.** Generated output is not delivered work. A PR that never merges delivered nothing, and a PR you rewrite next sprint delivered less than it appeared to.
* **Cost per effective PR is your total engineering cost, people and AI together, divided by effective PRs.** People cost dominates the numerator, so pick a loaded cost per developer and hold it constant. Trend the metric across periods rather than reading one snapshot; the level depends on your accounting, the direction does not.
* **Total value gain is the drop in cost per effective PR between two periods, multiplied by the PRs you delivered.** Of the three, it's the number that survives an executive meeting intact.

Rework rate is the guardrail underneath all three. A PR you merge and then rewrite spends from your AI budget twice, once to generate the code and once to redo it, and rework is where codebase rot first shows up as a number instead of a feeling.

LinearB is the context layer for your software factory, and the new AI ROI dashboard computes these measures against your own delivery data.

## **How will you know it works?**

You're building a software factory. How will you know it works?

On August 27, Dex Horthy, Zach Lloyd, and Dan Lines will answer that question live in a first-of-its-kind industry roundtable hosted by Dev Interrupted. One shut his factory down. One says building it is now the job. Both arguments turn on measurement decisions you're facing this quarter, and the session is a roundtable, not a demo. Bring your own numbers, or bring the reasons you don't have them yet.

[Save your seat](https://luma.com/88e9rrfg)

## Improve developer productivity with LinearB

Find us on

[](https://www.linkedin.com/company/linearb)
[](https://devinterrupted.substack.com/)

![Headshot3_d7231cbda7](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Headshot3_d7231cbda7?_a=BAVMn6ID0)

## Andrew Zigler

Andrew Zigler is a GTM Engineer at LinearB and the host of Dev Interrupted, a twice-weekly podcast and newsletter where 40k+ builders decode the transition to AI-native development and agentic orchestration. A classicist by training with a degree from The University of Texas at Austin, Andrew spent his early career teaching in Japan before channeling his interdisciplinary instincts into the tech world. His polymath background informs everything he builds, from automated workflows to the stories he tells about the seismic shifts reshaping software creation.

### Connect with

[](https://www.linkedin.com/in/andrewzigler)
[](https://substack.com/@zigler)
[](https://x.com/andrewzigler)

## Your next read

[![Cover image for You can now measure AI ROI with LinearB](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_1_dd1f47bae7?_a=BAVMn6ID0)](https://linearb.io/blog/ai-roi-dashboard)

AI

[You can now measure AI ROI with LinearB](https://linearb.io/blog/ai-roi-dashboard)

Today, we're launching the AI ROI dashboard in LinearB, live now for every customer with metrics builder enabled.

[![Cover image for AI agents are killing the pull request and reinventing CI/CD](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_5_496cdfde2d?_a=BAVMn6ID0)](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc)

AI

[AI agents are killing the pull request and reinventing CI/CD](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc)

CircleCI CTO Rob Zuber explains why AI adoption is killing the pull request and forcing engineering teams to completely reimagine the software development...

[![Cover image for Rippling's employee graph turns HR data into an agentic AI platform](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_be5ec4183f?_a=BAVMn6ID0)](https://linearb.io/blog/rippling-albert-strasheim-employee-graph-agentic-ai)

AI

[Rippling's employee graph turns HR data into an agentic AI platform](https://linearb.io/blog/rippling-albert-strasheim-employee-graph-agentic-ai)

Rippling CTO Albert Strasheim explains why the employee graph serves as the essential context layer for enterprise agentic AI. Discover how unifying HR, IT,...

## 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": "Your software factory needs a context layer",
  "url": "https://linearb.io/blog/software-factory-2026-ai-benchmarks-code-review-roi",
  "author": {
    "@type": "Person",
    "name": "Andrew Zigler"
  },
  "datePublished": "2026-08-04T07:00:00.000Z",
  "dateModified": "2026-08-04T07:00:00.000Z",
  "image": "https://assets.linearb.io/image/upload/v1785881186/unnamed_4_b35455ae7a.png",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "Data from 2.7 million pull requests across 253 engineering organizations shows a widening gap between developers using AI deeply and everyone else. An adoption dashboard can't tell you which side your team is on. Here's what a context layer has to see to answer it."
}
```

## 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)
- [Watch now](https://linearb.io/resources/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 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)
- [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)