Your team is about to double its code output. Have you stress-tested the pipeline that absorbs it?
Here is a thought experiment most organizations skip. Take your delivery pipeline as it exists today. Every stage, from code review through CI, testing, deployment, and production monitoring. Now double the merge request volume. Don’t change anything else. Same team size. Same review process. Same CI infrastructure. Same deployment procedure. Which stage fills up first?
This isn’t hypothetical. AI-assisted developers already produce two to four times the commits they did a year ago. Across 28.7 million CI workflows, CircleCI’s 2026 State of Software Delivery report measured the result for the median team: feature branch activity up 15%, main branch throughput down 7%. More code written. Less code delivered. As Rob Bowley observed in his analysis of the same data, 95% of teams are generating more work-in-progress that never ships.
The simulation is already running. Most organizations just didn’t choose to run it on paper first.
Walk the Pipeline
Take each stage of your delivery pipeline and ask one question: if merge request volume doubles tomorrow, does this stage absorb it or queue it?
Code review. Merge approvals remain 77% human-controlled. Developers spend roughly 24% of their time actually writing code; the other 76% is already allocated to reviews, meetings, planning, and maintenance. Where does the slack come from to review twice as many changes? In organizations that have already scaled AI-assisted development, review time increased 91% and average PR size grew 154%. If your pull requests age in queue, if reviewers skim instead of read, if AI-generated code waits longer than human-written code, review is your constraint.
CI and build. Main branch success sits at 70.8%, a five-year low. Workflows increased 59% year over year. Median recovery time is 72 minutes and growing 13% annually. If builds queue, if “just rerun it” is the default response to red, if recovery takes over an hour, CI is your constraint. An earlier article in this series explored CI signal reliability in depth. Here, CI is one station in the chain.
Deployment. Only 6% of organizations have fully automated their continuous delivery pipeline. 77% of teams report waiting on others for routine delivery work. Nearly half of deployments involving AI-generated code lead to problems. If your deployment process involves manual gates, approval queues, or weekend releases, deployment is your constraint.
Monitoring and incident response. Incident resolution takes 7.6 hours for teams using AI tools multiple times daily, compared to 6.3 hours for occasional users. 96% of the most frequent AI users work evenings and weekends multiple times a month. If MTTR is rising and your team absorbs incidents through overtime instead of automation, monitoring is your constraint.
Testing and security are stations in this chain too, and each deserves its own examination. Later articles in this series will address test meaningfulness and security posture under AI acceleration. For now, the point is the same: every stage has a capacity, and doubled volume will find the one with the least.
The simulation ends when you’ve found the stage that fills up first. That’s your constraint. What happens next is where most organizations get it wrong.
Are You Building the Right Thing Faster?
Before we address the constraint, there’s a question upstream of the entire pipeline that the simulation can’t answer: is what’s in the queue worth delivering?
Every feature is a hypothesis about what customers will value. AI is genuinely excellent at reducing the cost of testing those hypotheses early. Generating prototypes in hours instead of weeks. Exploring design alternatives that would have been too expensive to build by hand. Spinning up MVPs fast enough to test an idea before committing serious engineering effort. This is one of AI’s clearest wins. It collapses the cost of experimentation and lets teams cheaply validate direction before writing production code.
But reducing risk is not eliminating it. A prototype that tests well internally is still an assumption. Real validation only happens when a feature reaches production and delivers measurable value to actual customers. Risk reaches near-zero only when the hypothesis meets reality.
The pipeline is the path from hypothesis to validated outcome. Every stage that queues is a stage that delays that validation. When AI doubles merge request volume, it doesn’t just stress the pipeline. It doubles the rate at which unvalidated hypotheses accumulate in the system.
Donald Reinertsen’s work on product development flow makes the economics explicit: the cost of items sitting in queue includes the cost of delayed market feedback. Queues don’t just delay delivery. They delay learning. And DORA’s research has consistently identified deployment frequency as a proxy for learning speed. If teams aren’t shipping frequently, they’re delaying feedback, learning, and business impact.
Look at the CircleCI data again through this lens. Feature branches up 15%. Main branch down 7%. That’s not just a delivery failure. It’s a learning failure. More hypotheses generated. Fewer validated. The batch size finding from DORA’s 2024 report compounds it: AI causes changelists to grow. Bigger batches are bigger bets. Bigger bets take longer to validate. When they’re wrong, the waste is proportionally larger.
If your pipeline can’t close the learning loop fast, AI doesn’t make you more productive. It makes you more wrong, faster.
The Constraint Shifts
You’ve identified your first bottleneck. Most leaders assume that fixing it solves the problem. It doesn’t. It reveals the next one.
This is Goldratt’s Theory of Constraints, and it applies to software delivery as directly as it applies to a factory floor. System throughput is determined by the weakest link. Improving anything that isn’t the constraint is an illusion of progress.
The method has five steps.
Identify the constraint. The pipeline simulation found it. Maybe it’s review. Maybe it’s CI. Maybe it’s deployment. Maybe, after walking the pipeline, you realized the constraint is upstream of it entirely, in problem selection or requirements clarity.
Exploit the constraint. Maximize its current capacity without adding resources. If review is the bottleneck, reduce PR size, eliminate low-value review ceremonies, focus reviewers on what matters. If the constraint is upstream, use AI for what it’s genuinely good at: prototyping to validate assumptions before committing pipeline capacity to production code.
Subordinate everything else to the constraint. Match upstream throughput to constraint capacity. If review can absorb 1.2x the current volume, don’t generate 2x. If you can’t measure outcomes on twice the features, don’t commit twice the features to production. This is the hardest step because it means deliberately throttling AI output. It means saying: we could generate more code, but we choose not to, because the system can’t absorb it.
Elevate the constraint. Invest to increase its capacity. Add reviewers. Automate deployment. Build observability. This is the expensive step. Only do it after exploit and subordinate have been exhausted.
Repeat. The constraint will shift. Fixing review exposes CI. Fixing CI exposes deployment. Fixing pipeline throughput entirely exposes the question of whether you’re building the right thing. This is not a problem. This is how system improvement works. Run the simulation again.
DORA’s 2024 Accelerate State of DevOps report shows the cascade happening at industry scale. For every 25% increase in AI adoption, code quality improved 3.4%, review speed improved 3.1%, and approval speed improved 1.3%. Development metrics moved in the right direction. But delivery throughput dropped 1.5% and delivery stability dropped 7.2%. The development stages improved. The delivery constraint didn’t. DORA’s own explanation: “Improving the development process does not automatically improve software delivery, at least not without proper adherence to the basics of successful software delivery, like small batch sizes and robust testing mechanisms.”
The organizations that improved coding speed without addressing the constraint downstream saw development metrics go up and delivery metrics go down. Simultaneously. That’s what optimizing a non-constraint looks like.
Why It’s Worse Than You Think
The simulation shows where the pipeline breaks. Queuing theory explains why it breaks worse than expected.
Every stage of your delivery pipeline is a queue. Items arrive (merge requests, builds, deployments), get processed, and leave. When utilization rises, wait times don’t scale linearly. They explode.
The relationship is well-established. At 50% utilization, wait time roughly equals service time. At 80%, it’s four times. At 90%, nine times. At 95%, nineteen times. The curve isn’t a gentle slope. It’s a hockey stick.
Nick Arnosti offers the clearest intuition for why. Picture a food truck serving 50 customers per hour with capacity for 60. Utilization is 83%. Average flow time: about 6 minutes. Now increase demand by just 10%, to 55 customers per hour. Utilization rises to 92%. Flow time doubles to 12 minutes. A 10% increase in demand produced a 100% increase in wait time.
His rule of thumb: if excess capacity is cut in half, wait times roughly double.
Now consider what AI does to your delivery pipeline. It doesn’t just increase the arrival rate. More merge requests. Larger merge requests. More workflows. It simultaneously degrades the service rate. AI-generated code carries more issues per PR, so each review takes longer. PRs are 154% larger, so reviewers process fewer per hour. Reviewers are fatigued from the volume, so quality drops. Arrival rate up and service rate down at the same time. Both directions pushing utilization toward the breaking point.
You don’t need 10x the volume to collapse a delivery pipeline. At high utilization, 2x is more than enough. And the averages hide the worst cases. Some merge requests don’t just wait a bit longer. They wait days. The 90th and 99th percentile wait times are even more explosive than the average. That matches the lived experience of any developer who’s watched a PR sit in review while newer, smaller changes sailed past.
The Readiness Question
Harness surveyed 900 engineers in 2025 and found the variable that determines whether AI velocity helps or hurts: pipeline maturity.
Among organizations with low delivery automation, 55% reported faster shipping after AI adoption. With moderate automation, 64%. With full automation, 78%. The pipeline underneath determines the outcome.
Only 6% of organizations describe their continuous delivery as fully automated. 94% are running the experiment without the infrastructure to absorb the results.
Fewer than 1 in 20 teams have managed to scale both code creation and delivery simultaneously. The other 19 discovered their constraint in production, through incidents, burnout, and delivery metrics that moved in the wrong direction.
Double your merge request volume on paper. Walk each pipeline stage. Where does the queue form first? That’s the delivery question.
Now ask the harder one. Of everything sitting in that queue, how much has been validated as worth building? If the pipeline is the only thing standing between your hypothesis and your customer’s feedback, every bottleneck is a bet you can’t settle.
Fix the pipeline. But also ask what’s in it.


