Teams with high AI adoption merge 98% more pull requests while review time grows 91%, according to telemetry from Faros AI across more than 10,000 developers cited in a new analysis published by The New Stack. The report argues that coding agents have removed the headcount cap on parallel development, turning what was once a developer's four rotating branches into four simultaneous changes moving toward merge at the same time. The result is a mismatch: branching remains free at the code layer but disappears everywhere below it, leaving changes to queue behind shared staging clusters, databases, and dependent services that were never sized for the new arrival rate.
Nothing downstream of code generation was built for that volume, the report finds. Four agents can produce four candidate changes in an afternoon, but all four line up behind the same shared environment to find out whether they work. The queue is more expensive than it appears, because agents don't wait well—an agent blocked on an environment either sits idle holding a stale view of the system or plows ahead validating against mocks, and the developer supervising it context-switches away. By the time the shared environment frees up, the cheap part of the work has to be partially redone.
The report states that "the bottleneck isn't code generation, and it isn't review capacity alone. It's the first shared resource a change touches, because a branch that can't run is a branch that can't be trusted." The solution, according to the analysis, is to stop treating branching as something git does and start treating it as something every layer does—each layer of the stack should offer a cheap, instant, disposable branch primitive so a change can exist end to end without duplicating anything it didn't touch. Worktrees, pipeline caching, preview deploys, database branching, and environment sandboxing sound like five unrelated features, the report notes, but they're the same idea applied at five layers.
The reason the mismatch exists is that each layer discovered the branch primitive separately, and the upper layers learned it years ago. CI absorbed the lesson a decade ago, giving every branch its own pipeline run on a shared runner pool with build caches doing the copy-on-write work of reusing unchanged artifacts. The front end followed: on Vercel, every push to a non-production branch gets its own preview deployment by default, and reviewers stopped asking whether a change works on someone's laptop because the change is already running somewhere. Databases were supposed to be the hard case because they carry state, but Neon, PlanetScale, and Xata shipped branching anyway—a database branch is a copy-on-write view over shared storage pages, created in seconds regardless of database size. The report argues that if the layer with the most state can hand out branches in seconds, statelessness was never the real requirement, and whatever is still unbranched is unbranched by choice.
The microservices runtime resisted longest because it looks nothing like a file tree, with live traffic, a service graph, and dozens of moving dependencies. The copy-on-write move works anyway, the report explains: run one shared, stable version of the system continuously deployed from main, then for each change deploy only the services the change touches as a lightweight ephemeral environment and route each test request through the changed services while everything else falls through to the shared stable versions. The environment branch costs roughly what the changed services cost, which is why one can exist for every change an agent produces. Uber built SLATE to give each developer an ephemeral environment routed against shared production-grade dependencies because contention over staging could not keep up with its developer count, the report notes.
The report recommends that teams put the layers together so that an agent picking up a task gets a worktree, a pipeline run, a preview, a data branch, and a running environment from the start, making validation stop being the scarce resource that serializes everything upstream of it. Bitso, a crypto exchange with more than 250 engineers, pairs an environment branch with a database branch for each change so the runtime delta and the data delta travel together and shared staging stays out of the critical path. That end-to-end branch is what the phrase "agent-native software development lifecycle" should mean—not agents wired into yesterday's pipeline, but a stack where any change, human or machine, can exist at every layer for as long as validation takes and disappear afterward. The payoff compounds with agent count: when the branch primitive at every layer is a delta over something shared, validation concurrency scales with cluster capacity instead of with budget, and the number of changes a team can prove correct per day rises with the number it can generate. The choice engineering leaders face isn't whether to adopt agents, but whether their infrastructure can absorb the output without creating a longer queue that negates the productivity gain.