How Anthropic Merges 30,000 Code Changes a Day - Manish Kapur, Sonar & Addy Osmani, Anthropic
Manish Kapur of Sonar and Addy Osmani of Anthropic discuss why coding agents are opening pull requests faster than teams can review them, how light and dark software factories differ, how Anthropic scaled to around 30,000 merged changes a day with Claude doing first-pass review backed by verification evidence, new State of Code survey data, and why every loop in the factory needs independent, multi-layered verification.
Coding agents are now opening pull requests faster than teams can review them, and the bottleneck has shifted from writing code to trusting it. In a session at the AIE CODE summit, Manish Kapur of Sonar and Addy Osmani of Anthropic argued that the real question is who verifies the software factory.
Throughput is up, and merges are failing
CircleCI’s analysis of 28 million CI workflows this year found throughput up about 59%, yet roughly three in ten attempts to merge that code into production fail. Manish sees the same pattern across Sonar’s customers. The divide is between teams that merge agent output without reading it and teams that review it before merging. A show of hands at the start made the point: nearly everyone’s coding agent had opened a pull request in the past week, but very few could say they had reviewed every line they merged.
Light versus dark software factories
Addy frames a software factory as harnessing loops at scale and separates two versions. In a light factory, agents help plan, build, check and ship code repeatedly, but people still apply judgment and taste at each step. A dark factory is closer to a robotic car plant: it scopes, builds and checks work autonomously, and humans move up to defining intent and get pulled in only for exceptions. Most teams sit somewhere on that spectrum, and the journey is about earning enough trust to push automation further.
Coding is solved, confidence is not
The survey data cited shows 85% of organizations already use coding agents, heading toward near-universal adoption, and about three-quarters of developers say AI-generated code is produced faster than they can verify it. Addy argues the scarce resource is now confidence. Agents can generate tests, benchmarks, specs and other checks far more cheaply than before, and those artifacts are what made code good in the first place. An agent produces better output when it has a way to verify its own work, and getting that verification right can meaningfully improve outcomes.
How Anthropic reviews 30,000 changes a day
Anthropic went from about 2,500 merged changes a day earlier in the year to around 30,000. Addy described the workflow. Claude performs a first-pass review, but the key requirement is that it can exercise the software the way a real user would: running end-to-end tasks, opening the interface in a browser, and running linters and other checks. Hooks run on every edit, study the diffs and keep correcting the pull request in a fast loop. Anthropic also uses an internal code review product, and teams codify taste and best practice in shared files such as CLAUDE.md and agents.md so the agent consults them during review. People remain responsible for inspecting the agent’s evidence: a browser test, a recording of the agent clicking through a UI, or screenshots of mobile and desktop layouts. The goal is for the agent to supply as much verification evidence as possible.
What the State of Code survey shows
Sonar’s survey of more than a thousand developers found that 84% say AI helps get features and fixes into production faster, while pull requests are growing larger and more complex. Only about 31% of code reaches production without review, which Manish called a worrying figure for regulated and mission-critical systems. Software factory adoption is still early: about 5% of companies run them today, 34% expect to within a year, and 39% of financial services firms expect to. Only about 28% have approved agents and shared controls in place.
Where the next gains come from
Addy expects gains from two sources: better verification practices and continued model improvement. Models are already quite capable, so the bottleneck is knowing what verification means in practice. Telling teams to ‘verify the work’ invites the obvious question of what that entails. The useful answer involves end-to-end tests, property-based tests and visual verification, which together give teams enough confidence to merge changes automatically.
Multi-layered verification in every loop
Manish argued that verification must be multi-layered and applied in every loop, whether inside the agentic loop, in CI, or in code maintenance. He described three layers, each tuned to a different class of problem. The first is deterministic analysis, which catches bugs, security issues and vulnerabilities such as SQL injection and buffer overflows. The second is agentic review, where agents catch logic and intent problems that deterministic tools handle poorly. The third is software supply chain security, covering CVEs, malware and malicious packages. Sonar recommends a zero-trust posture, with each layer covering the gaps of the others.
Controls, permissions and sandboxes
Addy described enterprises that let engineering teams experiment with agents until they had hundreds or thousands running with no clear picture of what they were doing, touching systems, accessing data and possibly deploying to production. The concerns that come up most are control, permissions and sandboxing, and making sure agents do not escape their bounds. Sonar calls this approach guide rails rather than guardrails: instead of only blocking agents, guide them along defined paths and govern the agents in use.
Lightning round
On whether most teams will run light or dark factories by the end of 2027, the consensus was light factories with some dark corners, not fully dark operations for most teams. On labeling agent-written PRs, both agreed they should be labeled, at least for the next six to nine months until confidence in the factories grows. Addy noted Anthropic is less attached to crediting authorship and more focused on outcomes, but labeling supports auditability and tells reviewers which extra checks apply. Manish stressed that whoever kicked off the agent remains accountable and must fix anything that goes wrong. For the skill to build this year, Addy advised leaders to push teams to define what verification means and when agents can sign off on merges, and advised junior developers to gain experience with the different kinds of tests. On when an agent-opened PR is safe to merge, the answer was when you have full confidence nothing will go wrong, or have mitigated the risk as far as possible.
Key takeaways
Writing code is now the fastest part of shipping and is effectively solved. Strong review and verification are what let teams keep that speed without shipping blind. Fast to write is not fast to ship. Autonomy has to be earned, and each loop of the factory needs independent, automated verification so that its output can be trusted.