In our last issue, we shared a preview of data from our upcoming 2026 State of Software Delivery showing that the promised AI productivity boom isn’t all hype. Throughput across the CircleCI platform increased 59% year-over-year, by far the largest productivity jump we’ve ever recorded and a clear indication that AI-assisted coding is driving massive increases in change volume.
But the gains weren’t evenly distributed. The top 5% of teams nearly doubled their output, while the median team improved by just 4%.
Since then, we’ve released the full report. Alongside it, we launched the CircleCI Software Delivery Data Explorer, an interactive tool built on tens of millions of real CircleCI workflows that lets you benchmark your team’s throughput, duration, success rate, and MTTR against peers in your industry, region, or team size.
In this issue, we’re digging deeper into the performance divide we called out last time. What’s actually driving this separation, and what can you do about it?
The branch data tells the real story
To understand what’s causing the AI performance gap, it helps to know a little about how modern software gets built.
When a developer starts on something new, they typically don’t write code directly into the main codebase. They create a separate copy called a branch, a safe workspace where they can build and test without affecting anything in production or blocking their team from shipping other changes. When the work is done and the code passes automated checks, it gets reviewed and merged back into that main codebase, where it can be deployed to users.
Those two events mean very different things. Activity on feature branches tells you developers are working. Activity on the main branch tells you software is shipping. When you split the throughput data along those lines, the picture changes considerably.
For the top 5% of teams, throughput increased 26% on the main branch and 85% on feature branches between 2024 and 2025. Why is the jump so much bigger on feature branches? Because AI is particularly well-suited to the work that happens there: working out complex problems quickly, spinning up prototypes, and iterating quickly until the approach is right.
But the most important story is the increase in activity on main. Top performers are generating and shipping significantly more than they were just one year ago. That’s what it looks like when AI acceleration runs all the way through the delivery pipeline.
For everyone else, the picture is different. Teams in the top 10% saw feature branch throughput rise nearly 50%, but main branch activity was essentially flat at 1%.
And at the median, feature branch activity was up 15%, while main branch throughput actually declined by 7%.
In other words, the typical software team got marginally better at generating changes last year, but they got worse at getting those changes into customers’ hands.
For any business leader, a regression in the organization’s ability to deliver value is going to set off alarm bells. So what’s behind it? The short answer is that AI has made it significantly easier to write code, but the process of integrating that code into a production system involves a different set of challenges. And those challenges get harder, not easier, as the volume of incoming changes goes up.
Why AI-generated code is harder to land
It’s easy to say “integration is the bottleneck” and leave it there. But there are several distinct places between a developer finishing a piece of code and that code reaching production where things can slow down or break, and AI is putting pressure on all of them.
The first place AI generated changes run into trouble is code review. Most teams still require proposed changes to pass a manual review before they can be merged, and AI is making that queue harder to manage on two dimensions: volume and complexity.
We’ve already shown that AI is driving big increases in code activity for teams across the board. Those changes are not only happening more frequently, they’re also larger, denser, and touch more of the codebase than a human would in the same pass. Research by Faros AI and others has shown that AI adoption increases the size of pull requests by more than 150% on average.
What this means is that senior engineers tasked with reviewing AI-generated pull requests are facing an ever-growing review queue that is more difficult than ever to process. And they’re reporting all kinds of negative effects from it, from feelings of overwork and burnout to the tendency to take shortcuts and skim potentially risky code.
While the former is a serious risk to employee wellbeing and business continuity, only the latter is measurable in delivery data. And the impact is hard to ignore. Main branch success rates fell to 70.8% this year, the lowest in over five years and well below the 90% benchmark that indicates a healthy pipeline.
Roughly 3 in 10 attempts to merge changes into production are now failing, and when the main branch breaks, nothing else can ship until it’s fixed.
That brings us to a third place AI code tends to get stuck: fixing it when it breaks. Recovery times for failed builds have been climbing since AI-assisted development went mainstream in 2022. This year, the typical team takes 72 minutes to get back to green, a 13% increase from the previous year.
Recovery times have been getting longer as teams incorporate more AI-generated code into their workflows. The same challenges that slow down manual review – PR size and complexity – also make failures harder to diagnose. Larger changes create more places for bugs to hide. And when something breaks in code a model generated, the developer debugging it often has little intuition for why it was written the way it was or what it might have affected downstream.
CI/CD has to keep up
In a recent newsletter, we made the case for autonomous validation as the next evolution of CI/CD. The data in this report is the clearest argument yet for why that evolution is necessary.
The AI choke points we described are all symptoms of the same underlying weakness: delivery infrastructure built for a world where humans produced code at a human pace. That’s why we’re evolving CircleCI to deliver
Faster feedback so issues surface while context is still fresh, not after developers have moved on to the next AI-generated change
Deeper context across your build history, dependencies, configs, and policies to surface risk in AI-generated changes that a diff alone can’t reveal
Agentic capabilities that can resolve common, repeatable failures autonomously, without pulling an engineer off their work every time a flaky test or dependency conflict blocks the pipeline
When delivery pipelines can’t keep up, AI code is more likely to stall at review, break on merge, and burn engineering time on recovery. By rethinking CI/CD to operate at the same speed and scale as AI development, we’re taking concrete steps to remove the sources of friction that keep most teams from turning AI-generated code into shipped software.
Where do you stand?
If your team is generating more code than ever but struggling to get it across the finish line, you’re not alone. That’s the reality for the majority of teams in this year’s data.
You can learn more in the 2026 State of Software Delivery. It breaks down exactly where things are slowing down and what high performers are doing differently.
Want to see where your own numbers land? The Data Explorer lets you benchmark your delivery metrics against teams in your industry, region, and size band.
Benchmark your team in the Data Explorer →
And when you’re ready to turn all that AI-generated code into shipped software, CircleCI is free to get started.