In March 2026, agents started 17% of the pull requests opened on GitHub. By September the figure was above 40%, roughly 110 million pull requests in a single month and about six times March’s volume. Over the same twelve months GitHub recorded 34.3 billion commits and 1.3 billion merged pull requests, an average of 3.5 million merges a day.1
Read quickly, that looks like a story about delivery getting faster. It is not. It is a story about one stage of the lifecycle getting faster and five others being handed the difference.
That much is no longer contested. Anthropic’s AI-native SDLC playbook opens on the observation that code is no longer the bottleneck, and sets out how to rebuild the lifecycle around that fact, stage by stage, with committed artefacts and explicit human gates.5 Harness reached a compatible conclusion from the infrastructure side while describing what agent volume did to its own source control and CI.2 The premise is settled.
The harder question is the one that comes next. If the constraint moved, where is it now, in your organisation, this quarter? That has a different answer for a team maintaining a ten-year-old monolith than for one shipping a new surface, and a different answer in November than it had in June. It is not settled by a process redesign, however good. It is settled by measurement, and the measurements most teams are watching are the ones that move last.
The constraint moved, it did not disappear
Every delivery system has exactly one binding constraint at a time. Relieving it does not make the system uniformly faster; it exposes the next limit, usually somewhere nobody was watching. Review was sized around how fast humans write. Test suites were sized around how often humans push. Release processes, on-call rotations and ownership models all carry the same assumption. What is unusual about 2026 is the size of the step: the constraint did not ease by 10%, it went away, and the stages behind it absorbed the difference at once.
The infrastructure layer shows this clearly. GitHub Actions ran 45.4 billion jobs over the Octoverse year, up from 14.0 billion the year before, which works out to around 1,440 jobs every second.1 Harness, reporting on its own internal platform, described CI executions rising roughly sevenfold between November 2025 and September 2026 while the number of active projects grew only 1.7 times, and found pipelines queueing at peak because of concurrency limits rather than a shortage of compute.2 Those are vendor-reported figures from one environment, not an industry benchmark, but the shape is the point: the load arrived at a stage nobody had been treating as a capacity question.
The composition of the work changed too, not just the volume. Octoverse found that agent-started pull requests touch multiple files about 87% of the time, against 79% for pull requests with no detected agent involvement.1 A change that spans more files is a change that takes longer to review, conflicts more often, and is harder to attribute when something breaks. The unit of work got bigger at the same time as it got more frequent.
The uncomfortable part
Agent-started pull requests are not merging less often. By September, 90% of agent-involved pull requests merged within two weeks, against about 86% for the comparison group.1 The volume is going in. The question is what each stage gave up to let it through.
Throughput is a lagging signal
Here is the part that catches teams out. A saturating stage does not announce itself by slowing down. It announces itself by getting shallower.
When review volume doubles, reviewers do not take twice as long and let the queue grow. They skim. Comment density falls, approvals arrive without comments, and the median review gets faster, not slower. When test suites strain, teams do not wait; they mark things flaky and move on. When ownership thins, the code still merges. In each case the throughput metric holds steady or improves, while the thing that made the stage worth having quietly erodes.
DORA’s research points at the same phenomenon from the outcome side: higher AI adoption is associated with an increase in both software delivery throughput and software delivery instability, at the same time.3 Those two usually move in opposite directions. When they move together, a dashboard showing more merged changes and a shorter cycle time is not evidence that the system is healthy. It is evidence that the system is absorbing load, and the cost is showing up somewhere the dashboard is not looking.
Figure 1. Illustrative shape of stage saturation, not measured data.
The practical consequence is that the metric worth watching at every stage is a quality or depth metric, not a volume metric. Volume tells you what happened. Depth tells you what it cost.
The five ceilings
Behind code generation sit five stages, each with its own capacity, its own saturation signal, and its own fix. They tend to bind in roughly this order, though the order shifts with codebase age, test maturity and how much autonomy agents have been given.
Figure 2. The SDLC capacity ladder: five stages sized for a rate of change that no longer applies.
01Review
The first ceiling, and the one most teams have already hit. Reviewer attention does not scale with generated volume, and the failure mode is dilution rather than delay. We have written about this stage in detail in AI Is Writing More Code. Review Is Becoming the Bottleneck. The signals that move first are reviews per pull request, comment density, the share of approvals issued without comment, and the share of agent pull requests merged with no independent review at all.
02Verification
Tests and CI are the second ceiling, and they fail in two directions at once. Capacity strains, as the Actions and Harness figures show, while coverage of the changed code thins because the volume of changes outruns the tests written for them. The signal is not pipeline duration. It is the share of pull requests arriving with no test files touched, and the ratio of test commits to implementation commits on agent-attributed work compared with the human baseline.
03Integration
Merging is a capacity question once changes are both more frequent and broader. More files touched per change means more conflicts, longer-lived branches and more rebasing. The signal is first-time merge rate falling, the stock of stale open pull requests growing, and the size distribution of merged changes drifting upward.
04Operation
Deployment and incident response is where the cost of the preceding four stages becomes visible to people outside engineering. DORA’s ROI work models this explicitly: in its illustrative calculation, a change failure rate moving from 5% to 6% carried a $344,000 negative downtime impact.4 That figure is a model input rather than an observed result, but the direction is the finding. The signals are the DORA pair that measure consequence, change failure rate and time to restore service, read against AI-attributed share rather than as an org-wide average.
05Maintenance
The last ceiling is the slowest to appear and the hardest to reverse. Code that merged and shipped still has to be owned, understood and changed a year later. We looked at the economics of this in Your AI Code Passed Review. Production Sent the Bill. The signals are the share of code reworked within 30 days, the share still untouched after 30 days, post-review change rate, and how concentrated line ownership has become.
Figure 3. SDLC stages with the signal that shows saturation and the metric to watch.
How to tell which rung you are on
Three rules make this diagnosable rather than theoretical.
Baseline against human work, not against last year. An org-wide trend line blends agent-attributed and human-attributed work, and the blend moves every month, so the trend tells you very little. The comparison that carries information is agent-attributed work against the human baseline inside the same repository and the same period. If agent pull requests are reviewed half as deeply as human ones in the same repo, that is a finding. If the org average drifted, that is weather.
Watch the ratio, not the absolute. Every one of these signals is a ratio of care to volume. Comment density is attention per change. Test-to-implementation ratio is verification per change. Absolute counts rise with volume and reassure nobody.
Instrument one stage ahead of the pain. By the time operation hurts, the cause is two rungs up and three months old. The stage worth instrumenting is the one immediately after wherever you most recently added agent capacity.
Milestone Engineering Intelligence
Find out which stage saturates first if agent volume doubles.
Milestone reads the depth signal at every stage of your lifecycle, split by agent and human work, from your own repositories.
Book a Milestone demo
How Milestone makes the ladder visible
Milestone measures the lifecycle from the artefacts it actually produced, using read-only connections to repositories, pull requests, project tools and AI coding tools rather than surveys or seat counts. That matters here because the ladder is only diagnosable if every rung is read with the same method and the same AI attribution.
Review depth, measured rather than assumed
AI Code Quality reports post-review change rate, comment density, review cycles and whether review depth is thinning as volume grows, with agent and human work separated. Milestone Insights raises unreviewed agentic merges as a finding with severity, observed-versus-baseline and a named owner, instead of leaving it in a chart for somebody to notice.
Verification and integration
AI Engineering Productivity separates the coding phase from the review phase and groups pull requests by size, so a tool that speeds authoring while adding integration friction is visible as two different numbers rather than one net figure. First-time merge rate, stale open pull requests, test-file coverage in pull requests and test commit ratios are read per tool against a human baseline.
Operation
Deployment frequency, change lead time, change failure rate and time to restore service are reported alongside AI attribution, so the fourth rung can be read against the share of change that agents produced rather than as an org-wide average. Bugs linked to pull requests per thousand lines added connect the failure back to the change that caused it.
Maintenance and governance
Agent Observability covers session outcomes, retries and how often agent work needed human correction. Agent Governance turns those readings into a posture per agent — expand, monitor or restrict — scored on contribution rate, acceptance rate and autonomy level, with policy set by workload risk rather than applied uniformly.
Agent GovernanceExpand, monitor or restrict each agent, by workload risk.Learn governance →
Figure 4. An integration-rung signal read as a finding in Milestone Insights, with severity, observed versus baseline and a suggested action. Sample workspace; names and values are illustrative.
What this changes about 2027 planning
Most agent expansion plans being written this quarter describe how many more agents, on which repositories, under which tools. Very few describe what happens at the stage immediately behind them.
That is the planning change worth making. Expanding agent capacity without expanding the capacity of the next stage does not increase delivery, it relocates the queue. If review is already the binding constraint, more agents produce more waiting, more shallow approvals and more rework, at higher cost. The expansion only converts into delivered work if the rung above it has room.
DORA’s ROI research makes a compatible point from the investment side: returns depend less on which tools were bought than on the quality of the surrounding platform, workflow and alignment, and organisations should expect a J-curve where a temporary dip precedes the gain.4 A plan that budgets agents but not the verification and review capacity they will consume is a plan that has budgeted the dip without budgeting the recovery.
This is also where a playbook stops and measurement starts. Anthropic’s lifecycle plays are a credible account of what an AI-native SDLC should look like once it is built, and the artefact-and-gate model gives each stage something auditable to hand the next.5 What no playbook can tell you is which stage is binding in your codebase this quarter, or whether the redesign you shipped last quarter actually moved it. A target state is not a diagnosis, and the two need different instruments.
Conclusion
The step change in 2026 was real, and the data is unusually clear about its size. What the data does not say is that software delivery got faster by the same factor, because delivery is the whole lifecycle and only one stage of it was relieved.
The useful question for next year is not how much AI an organisation has adopted. It is which stage is currently binding, what evidence says so, and what is being done about the stage behind it. That question is answerable, and the signals that answer it degrade early and visibly, provided somebody is reading them.
Teams that know their rung will spend 2027 moving it. Teams that do not will spend it discovering, one incident at a time, where their lifecycle was narrower than their ambition.
Milestone Engineering Intelligence
Read every rung of your lifecycle from your own repositories.
Review depth, verification, merge behaviour, delivery stability and code survival, split by agent and human work.
Book a Milestone demo
FAQs
1. What is an agentic SDLC bottleneck?
A stage of the lifecycle whose capacity was sized for human-paced change and which saturates once agents raise the rate of change passing through it. Code generation is no longer the constraint, so the constraint moves downstream to review, verification, integration, operation or maintenance.
2. How much of software development is now agent-driven?
GitHub’s Octoverse 2026 report found agent-started pull requests passed 40% of all pull requests in September 2026, up from 17% in March, and that they more often touch multiple files than pull requests with no detected agent involvement. GitHub notes its agent detection is a floor, since not all agent use is visible.
3. Which SDLC metric shows that a stage is saturating?
A quality or depth metric rather than a throughput metric. Review depth, test coverage on changed files, first-time merge rate, change failure rate and 30-day code survival degrade before cycle time or deployment frequency move, because teams absorb volume by doing each step less thoroughly before they do it more slowly.
4. Why does throughput look healthy while an SDLC stage is failing?
Because throughput and stability can rise together. DORA’s research associates higher AI adoption with an increase in both software delivery throughput and software delivery instability, so a dashboard showing more merged changes can coexist with a system that is becoming less reliable.
5. How should engineering leaders plan agent expansion for 2027?
Plan the stage above the one being expanded. Adding agent capacity without adding review, verification or operational capacity relocates the constraint rather than removing it. The practical test is whether you can name, with evidence, which stage would saturate first if agent-attributed volume doubled next quarter.