The fastest engineering teams are now merging code at rates that dwarf traditional development velocity, according to a report published this month by The New Stack. Anthropic reported merging roughly 2,500 code changes each day in May, a figure that climbed beyond 30,000 daily by September. The analysis argues that the dividing line between high-velocity teams and the rest of the industry no longer rests on tooling or talent, but on whether organizations have rebuilt their delivery systems into what the sector now terms a "software factory," a largely autonomous pipeline where intent enters, agents plan and execute the work, and people control specifications and approval gates.
The report describes how coding has stopped serving as the constraint for these operations. Instead, developer infrastructure designed for human-scale throughput has become the choke point, raising questions about what continuous integration means when thousands of changes merge while tests remain in progress. Traditional development lifecycles measured the gap between elite and average teams in deploys per week. Agents have transformed that multiple into an exponent, the report states. The shift reflects a fundamental change in how verification works: agents add a generation step that floods later stages with changes written at machine speed, and they convert verification from a stage where people wait into a service agents query from inside their own feedback loop.
The authors write that a controller outrunning its sensor cannot accelerate, because it retries using stale data and ships the failures the sensor would have caught. The report frames the software factory as a control loop in which intent serves as the setpoint, agents act as the controller, and verification operates as the sensor. Autonomy scales only as far as the sensor can verify, a constraint the authors call back pressure. Anthropic's engineers continue reviewing every major codebase change, but they examine evidence that the change achieves its intended outcome rather than reading each line of code.
The analysis identifies three properties a sensor must deliver for a factory to function: latency, or how quickly the sensor reports a result; fidelity, meaning how closely the reading mirrors the real system; and bandwidth, which defines how many readings the sensor can handle simultaneously. Most teams achieve two of the three. Verifying a batch of pull requests on a shared environment provides fidelity but sacrifices latency and bandwidth, because the environment processes one reading at a time and returns results hours after the change, outside any agent's loop. Duplicating the full stack per change improves fidelity and isolation but adds latency, with provisioning stretching into tens of minutes, and bandwidth costs that grow with every concurrent agent. The report argues that at scale, a factory requires a method to supply each agent and each change with a realistic environment where actual services respond to its calls, without the expense or delay of stack duplication.
The report concludes that the gulf between teams merging 30,000 changes daily and everyone else isn't the agents themselves, which have become widely available. The distinction lies in a delivery system rebuilt around a sensor that reports in minutes, matches the production system, and runs for every change concurrently. On cloud-native systems, that sensor represents the most difficult component to construct, and it determines whether additional agents ship more software or simply break more of it. Organizations that run agents without rethinking verification will find themselves reviewing diffs all day, a bottleneck the report labels level three on a five-level ladder of AI coding maturity, where most teams plateau. The broader implication is that investments in agent tooling deliver returns only when matched by equivalent investments in the infrastructure that validates their output, a pairing that separates cosmetic automation from genuine transformation.