# AI agents are killing the pull request and reinventing CI/CD | LinearB Blog

> CircleCI CTO Rob Zuber explains why AI adoption is killing the pull request and forcing engineering teams to completely reimagine the software development lifecycle. Discover how CI/CD validation is moving left into agent loops, how code review is shifting toward intent-based verification, and how to manage soaring token spend.

_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": "AI agents are killing the pull request and reinventing CI/CD",
      "item": "https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc"
    }
  ]
}
```

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

/

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

/

AI agents are killing the pull request and reinventing CI/CD

# AI agents are killing the pull request and reinventing CI/CD

![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/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc#andrew-zigler)

|

July 31, 2026

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

[Rob Zuber](https://linearb.io/dev-interrupted/podcast/circleci-rob-zuber-pull-request-ai-agent-cicd), CTO at CircleCI, has spent nearly twelve years watching software delivery evolve, and for most of that stretch the change felt linear. The last couple of years snapped that line. Now he measures his own learning in days and weeks, not quarters, and he treats the churn as a feature rather than a bug. For the engineer who likes to take things apart and see how they work, there has never been more to disassemble.

Back in 2024, at an event in San Francisco, he asked a room full of engineers why anyone was still writing in a programming language designed for humans. That question aged well. It also spawned a hundred more that remain open, and the person best positioned to sit with those open questions tends to be a few steps ahead of the industry consensus. What follows is a map of where his head is at now, from the slow death of the pull request to the financial reality of token spend and the reinvention every leader is being forced to confront.

## The pull request has a target on its back

The industry loves to declare things dead. CI/CD gets that treatment often, and the business numbers disagree. The goal of [shipping high-quality software quickly](https://linearb.io/blog/code-generation-faster-shipping-isnt) to customers is not dead, even if the shape of the work keeps changing. Something else, though, deserves closer scrutiny. "One thing that I like to, I wouldn't say proclaim dead, but I would say has a target on its back, is the pull request," Zuber says.

The problem is the form factor. A PR is essentially a web page built for humans to interact on, and that assumption breaks the moment an agent uses a CLI to open one, another agent uses an API to read its state and leave comments, and a third agent reacts to those comments. As an interaction point it makes sense only in a transitional world where human inspection confirms the machines are behaving. Even that premise is shaky. "Humans were never great at reviewing code to begin with, right?" he notes. Hand the same PR to the same person on two different days, or before lunch versus after coffee, or with five minutes to spare before catching a bus, and the quality of the feedback swings wildly. The model always felt a little broken. Nobody felt compelled to fix it.

The pull request increasingly feels like a relic of a time when it served a purpose, and now functions more like a stage than an office. It has become a statement of record where systems arrive and apply their stamps, good or bad, while very little human attention lands on the code passing through the gates. The economics of the diff make this plain. A two-thousand-line agent-generated change broken into ten-line increments is nonsense as a review unit, and if a reviewer dislikes the result today, they no longer patch a few lines. They throw the whole thing away and start over.

## Agents are rebuilding the software development lifecycle itself

The deeper shift sits underneath all of this. "I feel like the job of engineering right now is building the tools that build things more than it is building the things," he says. Continuous improvement has been an industry practice for years, but now that practice scales by improving the machines that build the software rather than the software directly.

That means CI/CD moves left, into the developer loop, before code ever reaches a formal gate. CircleCI's Chunk Sidecars offer one shape of this, a direct-attached quality validation environment the agent uses as it works. The agent makes a change, checks whether it holds up, and adjusts before it ever tells the developer the work is ready. The validation quality mirrors a full CI environment, breaking away from the works-on-my-machine problem, but it happens in thirty-to-sixty-second cycles so that by the time code hits the classic merge gate, confidence is already high.

Then comes the harder question of who writes the tests. The agent does, and agents love to stub and mock everything until nothing real gets tested, because the goal is green, not correctness. That raises the need to validate the validation itself. Techniques sketched on napkins in the 1970s, like mutation testing, were once impossible for lack of compute and now run on a phone. Pair that with an LLM analyzing code to flag the trouble spots, and risk assessment becomes the real work. The payoff is a closed loop. For years the SDLC behaved like a single-player instrument that engineers held and played by hand. Now the loop can run itself and improve every time a human has to step in, and the destination is clear even if the answers are not. "I really think that we will figure out how to do [code review](https://linearb.io/blog/introducing-ai-powered-code-review-with-git-stream), code merging in a way that doesn't really involve a human," he says.

## Code review must evolve for machine-scale output

Assume, for a moment, that a human still reads the diff. The traditional presentation, alphabetical by file tree with changed lines in numerical order, works fine for ten lines on a screen. It collapses entirely against the volume an agent produces in minutes, and GitHub already renders that collapse literally, refusing to display diffs that grow too large. A page that says the diff is too big to render is useless to the person meant to review it.

The open question is what a useful diff looks like at that scale. "What is the structural intent-oriented diff?" he asks. The idea is that machines carry the intent forward, confirm the change does what that intent implies, and surface only the sections that genuinely warrant a human eye, flagged for security or logic that looks suspect. The analogy is a legal document handed over with tape flags marking where to sign. Better reviewers than the signer have already done the reading, and what actually matters is who reviewed it and how much they are trusted.

This same pattern suggests the process moves toward a DocuSign experience of PRs that walks a reviewer through only the lines it wants signed off. Accountability does not vanish. Someone still answers for the merge. What changes is the currency. [Exhaustive line-reading gives way to risk assessment](https://linearb.io/platform/programmable-workflows/features) and trust in the reviewer, and the presentation layer itself splits in two, because a semantic folder hierarchy that helps a human orient is pure token noise to an agent counting every unit of context it consumes.

## Token spend is now a real financial control problem

The excitement carries a bill. The span between motivating everyone to adopt these tools because the opportunity is real and asking what everyone is actually spending was, in many organizations, about a week. The raw math can look irresistible. Triple an engineer's outcomes for a fifty-percent cost increase and most leaders take that trade every day. But real money leaves real bank accounts, and the return arrives on a delay. "Uber kind of famously, and there's been other examples since, came out in March and said, 'We spent our whole token budget for the year,'" he says. Investors and business leaders care about total cash spend, and revenue from a merge does not materialize the instant the code lands.

[Predictability matters](https://linearb.io/solutions/predictable-software-delivery) as much as magnitude here, sometimes more. A forecastable cost can be managed around. A spike that appears because one developer discovered how to spin up a hundred parallel agents running around the clock, producing nothing, drains the budget before anyone notices. "Predictability is often as valuable, if not more valuable in finance than the actual magnitude, right?" he notes. So teams build controls, caps, and routing, and educate people that not every task needs the most expensive model.

At CircleCI the approach avoids both extremes of demanding that every individual master every detail and forcing a new tool down everyone's throat daily. Some people just want to get work done, and a stack that changes every morning leaves no time to build anything. Instead, watch the outliers. When spend outpaces output, ask what someone is doing, then tune it, perhaps by switching a setting from Opus to Sonnet to see if the result holds. Distribute what works as reusable skills so the whole organization benefits without having to think about it, since a skill reaches an outcome faster and burns fewer tokens than an agent solving the same problem from scratch again and again. "We're trying to be like a little reasoned about it and pick the points that are gonna be high leverage," he says. Humans forget and mistype, so the leverage lives in the defaults people inherit for free, not in perfect individual discipline.

## Leaders must relearn engineering to lead it now

The industry's opening move can be captured with an image of executives rolling up in Ferraris and tossing the keys to the parking lot. Wheels spin, smoke rises, all the gas gets burned, and when it clears nobody has built anything or won a race. Getting a handle on AI spend and[ tying it to outcomes](https://linearb.io/blog/ai-measurement-framework) is the work most orgs skipped.

Doing that work requires a kind of credibility that no longer transfers automatically from years of hands-on architecture. Much like the individual contributor forced to ask what expertise still matters, leaders face the same reckoning, because their authority came from knowing how systems fit together, and while that knowledge still holds, the day-to-day act of building has completely changed. Telling an engineer to choose the right model invites the obvious reply of when, and answering that with a shrug helps no one. "To have useful, credible, productive conversations with your team about how we're going to use these tools effectively and what that might mean for us, as a leader, you need to understand it," Zuber says.

So the investment is personal and concrete: using Claude Code, Cursor, Codex, and open-weight models, pushing the cheapest possible option until it produced abysmal results, and learning from that exactly what a better system would need. "It's been a big investment for me in just developing my own understanding," he says. For anyone in developer tools there is an added driver, since understanding what customers endure is impossible without living it first. The traditional org chart faces the same pressure. The clean delineation of designer, PM, EM, and tech lead is breaking down, and comfort with reinvention becomes the trait that separates leaders who adapt from those who cling. For anyone whose whole career was built on structuring large organizations one proven way, "someone just pointed a blowtorch at your playbook," he says. Maybe the dragon burnt it.

The through-line across every one of these shifts is that the code itself is no longer where the truth lives. Intent moves upstream into the transcripts, and validation moves downstream into observability once software is running in the wild. In that world CI/CD does not disappear. It levels up into a harness that stretches from a developer's local loop and their on-demand agents all the way out to the front gates where product meets customers, and closing that impossibly large loop is the engineering problem worth building toward. Change management cannot keep pace with daily change, and helping people through that gap is now a core part of the job.

To hear more of Rob Zuber's insights on the death of the pull request, managing AI token spend, and leading engineering teams through constant reinvention, listen to the full episode on the Dev Interrupted podcast.

## 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 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,...

[![Cover image for Deterministic guardrails must evolve to control probabilistic AI systems](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_5_f5375661ec?_a=BAVMn6ID0)](https://linearb.io/blog/launchdarkly-cameron-etezadi-deterministic-guardrails-probabilistic-ai-darkfactory)

AI

[Deterministic guardrails must evolve to control probabilistic AI systems](https://linearb.io/blog/launchdarkly-cameron-etezadi-deterministic-guardrails-probabilistic-ai-darkfactory)

LaunchDarkly CTO Cameron Etezadi explains why traditional engineering pipelines are breaking down in a probabilistic, AI-driven world. Discover how to safely...

[![Cover image for Slack turns channels into the context engine for agentic AI](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_077524ba8b?_a=BAVMn6ID0)](https://linearb.io/blog/slack-jaime-delanghe-mcp-agent-context-channels)

AI

[Slack turns channels into the context engine for agentic AI](https://linearb.io/blog/slack-jaime-delanghe-mcp-agent-context-channels)

Slack Chief Product Officer Jaime DeLanghe breaks down how channels serve as the foundational context layer for human-agent collaboration. Learn why Slack is...

## 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": "AI agents are killing the pull request and reinventing CI/CD",
  "url": "https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc",
  "author": {
    "@type": "Person",
    "name": "Andrew Zigler"
  },
  "datePublished": "2026-07-31T07:00:00.000Z",
  "dateModified": "2026-07-31T07:00:00.000Z",
  "image": "https://assets.linearb.io/image/upload/v1785536923/Blog_Post_Name_2400x1256_5_496cdfde2d.png",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "CircleCI CTO Rob Zuber explains why AI adoption is killing the pull request and forcing engineering teams to completely reimagine the software development lifecycle. Discover how CI/CD validation is moving left into agent loops, how code review is shifting toward intent-based verification, and how to manage soaring token spend."
}
```

## 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/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 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)