Yesterday, we published our Q2 Pulse report, a follow-up to our annual State of Software Delivery that digs into a question engineering leaders are running into everywhere: why do some teams turn AI-generated code into shipped software while others watch feature branches pile up?
AI has made writing code cheaper and faster than ever. Every team we look at is generating more of it than they were a year ago. But the data keeps showing the same split: code volume is up almost everywhere. Shipped changes are not.
The bottleneck is validation. A change goes out, a pipeline takes several minutes to run, something fails, and the cycle restarts before anything merges into main. Each round trip drains both engineering time and delivery budget. In our previous issue, we modeled how a 50-developer team can spend close to $900,000 a year on avoidable validation cycles, driven by repeat CI runs and the tokens agents spend reloading context after slow feedback breaks the flow.
The most productive teams are pulling away because they ship in fewer cycles. That lifts individual and team velocity while driving down the cost of each change. In our Q2 Pulse report, we went behind the scenes with the most productive organizations on CircleCI to isolate the habits that help them break the delivery bottleneck without breaking the bank. Below, we’ll share three of them.
The teams setting the pace
The cohort we studied includes 20 anonymized organizations with the highest main-branch throughput on our platform. They span sizes, regions, and industries, with a concentration in security and developer tooling and additional representation from fintech, e-commerce, logistics, and energy.
As a group, they run an average of 2,165 production-branch workflows every day, a 72% jump from a year ago. That builds on the AI-driven volume surge we flagged in our Q1 report, when average daily workflow runs across CircleCI were up 59% year over year. The new finding is sharper: among the teams pushing hardest, increased activity is translating into dramatically higher production-branch throughput.
The gap between these teams and everyone else is widening. Across the platform, the most productive teams now ship roughly 9x the validated code of a typical team, up from 8x just a quarter ago. Their operational advantage comes down to three distinct habits.
Habit 1: Every engineer ships more finished work
The most productive teams get more production-ready work through the system per contributor. We measure this as main-branch workflows per contributor per day: a practical signal for how often validated work is reaching the production branch.
On a typical team, that comes out to about 1 main-branch workflow per contributor per day. Among high performers, it’s closer to 3. Among the 20 most productive teams, it’s around 12. That puts them at more than 10x the output of a typical team. It also shows how quickly the bar is rising: this same set of elite teams has nearly doubled per-contributor throughput in just one year.
High per-contributor throughput is the natural result of a delivery system built around frequent integration. Branches stay short-lived, validation runs continuously, and changes do not sit for days waiting on review or late-stage cleanup.
Frequent integration matters even more with AI in the loop. As more code enters the system, the teams that pull ahead are the ones that can move changes quickly from generation to validation to merge.
Habit 2: Validation runs beyond the manual push
The mechanics behind high volume become clear when looking at how top teams trigger validation. Engineers are not manually pushing code every single time they need to find out whether something works.
Most teams only run CI when someone pushes code, and the median team triggers nearly 100% of its pipelines that way. The most productive teams do not:
Direct pushes: Account for only about 68% of their triggers.
Automated triggers: The remaining 32% comes from scheduled runs, API calls, dependency-update checks, and post-deploy verification.
Their CI keeps validating the codebase and deployment lifecycle even after devs have closed their laptops.
A broader trigger mix gives teams more places to catch problems, from dependency health to release verification. Done well, it can also keep push-driven feedback focused on the change a developer is trying to merge, instead of mixing that signal with unrelated failures that could have been caught elsewhere.
Habit 3: Fewer validation cycles per shipped change
Throughput and automation drive volume. Efficiency keeps that volume affordable.
We track efficiency with a metric called Merge Efficiency Ratio, or MER: the number of feature-branch workflow runs for every workflow that runs on main. A high MER means work takes more rounds of pre-merge validation before it’s ready.
Every extra feature-branch cycle means more compute spent validating the same change. In an agentic workflow, it can also mean more tokens spent reloading context and generating fixes each time a slow run reports back. A team can ship a lot and still bleed money if every change takes five or six cycles to ship. The most productive teams keep cycles low, so their higher volume moves into production without a runaway bill behind it.
Less waiting, more shipping
Higher output per engineer, validation beyond the push, and fewer cycles per change all point to the same operating principle: the best teams reduce the distance between writing code, validating it, and merging it.
That is how more code turns into more shipped software. Feedback stays fast, branches stay short, and changes reach production instead of piling up. Just as important, the cost per change goes down instead of up.
The full Q2 Pulse report lays out the cohort behind the numbers, the implementation patterns behind each habit, and what it costs to operate at this level.
The report focuses on the operating model behind high-throughput teams. Chunk is one practical way to start applying the same principle: move routine validation out of the slow CI loop and into the moment code is being written.
Chunk sidecars run validation in the inner loop, right alongside your agent, so lint failures, broken tests, and syntax errors get caught in seconds while the context is still warm, instead of after a five-minute round trip through CI. In our own testing, microbuilds delivered feedback with up to 30x less compute usage than a full pipeline run and about 5x fewer tokens.
Chunk sidecars are available now, free on every CircleCI plan. One command gets you started: brew install CircleCI-Public/circleci/chunk