What Determines Software Delivery Performance With AI?

In the agentic era, review latency, batch size, and deployment checks determine whether AI-generated code reaches production safely. Coding agents increase merged pull request volume by about 24% per engineer per day, which puts pressure on unchanged review, testing, and deployment stages.

Developers now open review queues filled with AI-generated pull requests that pass local checks and then wait days for human verification. Engineering leaders funded broad AI coding tool rollouts, and adoption followed: DORA's 2025 research found the median technology professional now spends two hours daily working alongside AI. Delivery dashboards still lagged in high-adoption organizations.

The gap appears as a 30% increase in pull requests created with AI assistance while organizations release roughly 2% more features to production. The bottleneck sits in the software delivery lifecycle stages after code generation.

Loop design explains that gap. Review, testing, and deployment queues grow downstream of faster code generation, so more reviewers or more agent seats leave the constraint in place. This guide traces where the 2024 and 2025 DORA reports located the constraint, why process design outpredicts headcount, and how to reset a delivery baseline.

AI Amplifies the Delivery System You Already Have

AI magnifies the delivery loop already in place. The same code-generation speedup produces different throughput and stability outcomes depending on architecture, feedback latency, and team process. DORA renamed its annual publication for 2025 as the State of AI-assisted Software Development. Released September 2025, the report drew on surveys of nearly 5,000 technology professionals and more than 100 hours of qualitative interviews. Its finding reframes the investment question for CTOs: "AI's primary role is that of an amplifier, magnifying the strengths of high-performing organizations and the dysfunctions of struggling ones." The report adds that strategic focus on the underlying organizational system produces the greatest AI returns, exceeding what the tools alone deliver.

The 2024 and 2025 reports diverge on throughput but agree on stability. Google Cloud's 2024 DORA announcement reported an estimated 1.5% decrease in delivery throughput alongside AI adoption, while the 2025 DORA announcement reversed the throughput signal into a positive correlation. The stability finding gives leaders the planning signal, and the comparison below shows where the two research cycles align and where they part ways:

The 2024 analysis hypothesized that AI lets respondents produce much more code in the same amount of time, which likely increases changelist size. Larger changes are slower and more prone to creating instability.

The amplifier effect depends on the delivery loop. That loop sits underneath the measured 30-98% PR-volume increase. Teams with loosely coupled architectures and fast feedback loops absorb AI-generated changes because dependencies are smaller and review paths are faster. Teams constrained by tightly coupled systems see changes accumulate behind the same queues. Plandek's 2026 benchmarks found lower-performing teams using AI cut Lead Time to Value by nearly 50% against similar non-AI teams, while top performers improved only 10-15% on the same metric. The size of the gain depends on the state of the underlying system.

AI widens the distance between well-designed and poorly designed delivery systems. It closes the larger Lead Time to Value gap first, while teams near their loop ceiling have only 10-15% improvement headroom in Plandek's benchmark. In systems where AI increases PR volume by 30-98% and downstream stages produce only roughly 2% more production features, the loop sets the ceiling. In DORA's 2025 survey of nearly 5,000 technology professionals, AI also shows no relationship with reducing friction or burnout, so leaders should address developer experience directly.

The Constraint Moved Downstream to Review and Verification

Review, testing, and verification queues now determine software delivery performance after code generation accelerates. GitLab's November 2025 Global DevSecOps Report, surveying 3,266 respondents, named this the "AI Paradox": "Coding is only 20% of the software lifecycle. Remove bottlenecks in the remaining 80%." The report documents code review overload, where engineers review AI code while feature work stalls. It also documents security scanning backlog, where AI generates code faster than security teams can scan it, and testing backlog, where code arrives faster than teams can write tests for it.

Evidence from independent datasets points to the same downstream pressure. LinearB's 2026 benchmarks drew on 8.1 million PRs from 4,800 engineering teams and found agentic AI pull requests wait 5.3x longer before a reviewer picks them up and run 2.6x larger on average. Swarmia's data across 1,450+ organizations shows median batch size roughly doubled between Q1 2025 and Q1 2026, "with batch size growing about 2.5x faster from October onward as agent adoption hit the mainstream." Faros AI's telemetry across 22,000 developers and 4,000 teams quantifies the chain across the full delivery pipeline, drawing on both its 2025 baseline and its 2026 "Acceleration Whiplash" follow-up:

The pattern is "Acceleration Whiplash": "real throughput gains at the top, compounding quality costs at every stage below."

Practitioners report the same mechanics. In one large engineering organization, 90% of developers using AI daily coincided with a 30% increase in code change per developer alongside more quality concerns and longer review time. The response combined background agents with guardrails around test automation. Human review mandates create a deployment bottleneck when AI-generated code accumulates faster than reviewers can clear it. Working code then sits behind backlogs of thousands of lines.

Those reports explain why review policy, repository context, and human checkpoints have to move earlier. The Augment Code Context Engine delivers 5-10x task speed-up on complex multi-file workflows by processing entire codebases across 400,000+ files through semantic dependency graph analysis. Augment Cosmos, the unified cloud agents platform, extends that architectural understanding across the full delivery lifecycle through three primitives. Environments define where agents run and what they can touch. Experts define how agents behave and what events they subscribe to. Sessions capture auditable, replayable workflows. Together they keep repository context, review policies, and human checkpoints attached to shared delivery workflows. Without that shared layer, teams see recurring failure modes:

• Setups fragment as every engineer builds a personal workflow.
• Expertise gets trapped: the engineer who figured out the great prompt for the billing service has it in a private config and nowhere else.
• No quality signal exists across teams.
• Humans get pulled in only at the final PR, where catching problems costs the most.

These failure modes put prompts, quality signals, and human judgment too late in the delivery loop.

The Augment Code review agent achieves a 59% F-score in a benchmark of context-aware pull request analysis, so reviewers can inspect dependencies across enterprise repositories rather than trace them by hand. Engineering teams evaluating code review tools for engineering teams can compare that context-aware pattern with traditional review workflows.

[ Meet Cosmos ]

Run your software agents at scale

Cosmos gives your agents the context, tools, and feedback loops they need to get better with every workflow.

Try it out

Loop Design Predicts Delivery Performance More Reliably Than Headcount

Batch size, queue length, and feedback latency predict whether code reaches production safely. A decade of delivery research ties performance gaps to process design. The Accelerate research synthesis (36,000+ technical professionals, 2014-2019) found high performers achieved 46x more frequent code deployments, 440x faster lead time from commit to deploy, 170x faster mean time to recover, and 5x lower change failure rate than low performers. High performers excelled at both speed and stability, which means the throughput-stability tension comes from loop design. The 2023 DORA report identified continuous integration, loosely coupled teams, and fast code reviews as the drivers.

Headcount carries structural diseconomies. Brooks's law holds that adding manpower to a late software project makes it later, because communication paths grow as n(n-1)/2 and new members impose training overhead. Flow research locates the root cause elsewhere: "Invisible and unmanaged queues are the underlying root cause of poor product development performance." Cycle time improvement through batch size reduction is independent of demand or capacity changes; it requires shrinking work-in-progress.

LinearB Labs confirms where delivery time goes through its analysis of millions of PRs. Average cycle time runs seven days, and code sits in PR review for five of those seven. Small PRs get picked up up to 20x faster than large ones. GitKraken's 2026 benchmarks show elite teams merge 50% of PRs within 24 hours and 90% within 48, with time to first review under four business hours. PR size, pickup latency, and first-review targets determine whether review consumes five of seven cycle-time days or clears 50% of PRs within 24 hours.

Organizations that pulled those levers improved delivery without adding people:

• Pinterest replaced package-name test splitting, where the slowest shard gated the whole build, with runtime-aware sharding that balances work across shards by measured execution time. That change cut Android end-to-end CI build times by more than 36% and shortened feedback latency for developers, with no headcount increase mentioned.
• Code Climate standardized pull request descriptions in a controlled two-week experiment, with no changes in team composition or work complexity, and PR review speed increased 30% purely because reviewers spent less time reconstructing intent.
• A longitudinal arXiv study of a production multi-agent code review system found a 31.8% reduction in PR cycle time against a six-month baseline. The gain accrued as the review stage absorbed load that otherwise would have queued.

UpLevel's analysis of roughly 800 developers provides the counter-case. Copilot access produced no significant change in efficiency metrics while the Copilot group introduced 41% more bugs. Tooling alone can leave team-level delivery flat and increase bugs.

Engineering Velocity Metrics That Survive AI-Inflated Output

In the AI era, engineering velocity metrics survive output inflation when they measure production outcomes, instability, and rework rather than raw code volume. DORA evolved its four software delivery metrics into five in 2024. Researchers added deployment rework rate after identifying that change failure rate had been acting as a proxy for rework. The Quick Check incorporated it in April 2026. The revised set anchors any AI-era baseline:

Attribution and output inflation make these numbers harder to read in the agentic era. Attribution creates one distortion because DORA measures outcomes without identifying whether AI or humans authored code. Output inflation creates another because AI-generated code runs "+20% larger on average than human-generated code" and functions as an input metric that can correlate with AI usage cost. LOC-based measurement inverts value entirely, since the most valuable work in the AI era, such as refactoring, simplifying, and deleting bad AI-generated code, registers as zero or negative productivity.

Hallucinated code often appears in the dashboard as AI-assisted rework, revert rate movement, or defect attribution noise. Model routing can address part of that measurement problem at the generation step. Prism routing across Claude, GPT, Gemini, and Kimi models reduces hallucinations by 40% by selecting the right model for the task, so every change no longer runs through one default model. The table below maps each measurement gap to a countermeasure implied by the metrics themselves:

Single-metric targets increase gaming risk in AI-assisted delivery dashboards. Deployment-frequency mandates can push teams toward output volume while ignoring change failure rate and deployment rework rate. Guidance warns that mandates like "every application must deploy multiple times per day by year's end" invite gaming. It recommends multiple metrics "with a healthy amount of tension between them." A June 2026 DORA post extends the warning to AI-era vanity measures, calling model-consumption leaderboards "a dangerous trap." A rule of thumb calls for at least two to three metrics in tension with each other.

Leaders should also distrust perceived gains, because perception and measurement point in opposite directions. METR's July 2025 randomized controlled trial found experienced developers took 19% longer on tasks with AI while estimating they were 20% faster. METR's February 2026 follow-up study of 57 developers across 800+ tasks corrected for a selection-effect bias in the original sample and reported only a 4% slowdown (confidence interval of -15% to +9%), concluding that AI likely provides productivity benefits with newer tools. Even under the updated estimate, review-time perception still overshoots measured outcomes: New Relic's 2026 survey shows 94% of leaders rate AI-generated code as higher quality at review time, yet 78% report more incidents after it ships. A leader who trusts the review-time impression will systematically overestimate delivery health.

Leaders can close this gap by supplementing the DORA five with AI-segmented measures. A utilization, impact, and cost framework tracks metrics such as PR revert rate and change failure rate compared across AI-usage cohorts such as non-users, light, moderate, and heavy users. The unsolved problem is value per PR: one agent task can now write tens of PRs, PR size is growing, and higher code volume can leave delivered value flat. Use this guide to assess which agent metrics mislead before any dashboard redesign.

How to Reset Your Software Delivery Performance Baseline

Resetting a software delivery performance baseline starts with measurement before and after agent adoption. Teams then redesign the stages where PR pickup latency, batch size, and rework data show queues forming. The baseline guidance is explicit: "After you establish a baseline of your current software delivery performance, your team can use the DORA metrics to observe the impact of implementing generative AI on software delivery for your application." The budget framing makes the same point: "The key is establishing clear baselines today. Without baselines, teams cannot gauge progress accurately as they shift towards AI-driven engineering."

For a VP of Engineering, the sequence starts with instrumentation and ends with reusable corrections.

1. Baseline the five DORA metrics before expanding any rollout. Segment AI-assisted from human-only changes; tagging AI-assisted PRs or using file-system-level detection helps because developers often heavily modify accepted code before commit.
2. Instrument the review loop directly. Track PR pickup latency by cohort, PR size distribution, and time to first review against the four-business-hour target. These are the numbers agent adoption distorts first.
3. Audit against DORA's AI Capabilities Model (December 2025). The model covers fast flow and feedback, flexible infrastructure, responsible AI use, effective AI use, trusted team dynamics, user-centric focus, and quality internal platforms. User-centric focus is the most critical of the seven because a faster loop that produces the wrong output reaches the wrong destination sooner: without a user anchor, "AI can make it easier to build the wrong thing faster than ever before." Audit it first, because tuning speed cannot fix a mis-aimed loop. Quality internal platforms come next, because teams need that foundation to realize value from AI investments. Teams onboarding new engineers to large repositories with the Augment Code Context Engine reduce ramp time from 6 weeks to 6 days, since repository context gives new developers a map of conventions, dependencies, and production change paths.
4. Redesign human checkpoints before adding review capacity. Cosmos collapses 8 human interruptions in the standard delivery loop into 3 checkpoints. Agent Experts handle review, testing, and deployment stages while humans steer prioritization, spec and intent review, and repository-context decisions as code evolves. Teams set the policies for where human judgment is required, and the platform enforces them.
5. Save reviewed corrections so future agent sessions can reuse them. Reviewed corrections should become auditable and reusable so they persist beyond one engineer's config. Engineers coached a public tester-agent example, Milo, over Slack and distilled those corrections into tenant-shared memory. The example shows how reviewed corrections can persist across governed Sessions for repeated testing tasks in a specific environment.

Reset Your Delivery Baseline Before the Next Agent Rollout

Agent adoption is pulling apart throughput and stability, which moved together for a decade of DORA research. The split widens wherever the loop stays static. Individual adoption alone does not change organization-level delivery. The next step is a quarter-long baseline: instrument the five DORA metrics, segment AI-assisted from human-only changes, and measure PR pickup latency before approving further agent spend. Then redesign checkpoints where the data shows queues forming, pairing event-driven Experts with auditable Sessions in Cosmos so humans steer prioritization, spec review, and repository-context decisions before agent changes clear review.

FAQ

Related

• Best AI Code Review Tools for Engineering Teams
• Why AI Agent Metrics Lie: What CTOs Should Track
• Top AI Coding Assistants for Enterprise Codebases
• Best Cloud Development Environments for AI Agents
• Leading Pull Request Automation Tools for Engineering Teams