How Anthropic Merges 30,000 Code Changes a Day

Manish Kapur, Sonar, Addy Osmani, Anthropic18:53 · Oct 2026 · 31K views
Thumbnail for How Anthropic Merges 30,000 Code Changes a Day Watch on YouTube
TL;DR
  1. 1

    Coding agents have made code production fast, but teams still need evidence that changes are correct before merging.

  2. 2

    Anthropic uses Claude for first-pass review, browser checks, tests, linting, and other verification steps before people assess the evidence.

  3. 3

    Software factories need independent verification in every loop, with controls for permissions, agent identity, telemetry, and sandbox access.

Summary

Manish Kapur and Addy Osmani discuss the gap between generating code quickly and merging it with confidence. Osmani describes light software factories, where people remain involved throughout planning, building, checking, and shipping, and dark factories, where people mainly set intent and handle exceptions. Anthropic has increased its daily merged changes from about 2,500 in May to about 30,000, using Claude for first-pass review and asking it to produce evidence from end-to-end tasks, browser checks, linting, tests, screenshots, and videos. Kapur presents Sonar's survey findings on larger pull requests and more unreviewed code. Both speakers argue that verification must be specific and layered. Deterministic checks, agent review, and software supply chain security catch different classes of problems. The discussion also covers agent permissions, sandboxes, telemetry, labeling agent-written pull requests, and human accountability for changes launched by an agent.

Key ideas
02:55

Software factories range from human-guided loops to mostly autonomous production

Addy Osmani describes a light software factory as a repeated cycle of planning, building, checking, and shipping where people still apply judgment and taste. A dark factory runs those steps more independently, with people focused on intent and called in for major exceptions. Teams can move along this spectrum as their agents produce better verification evidence. Manish Kapur compares the factory to a production line that starts with intent and specifications, then moves through coding and other software development steps. The difference is how often people take part in each step.

03:48

The hard problem is confidence, because generated code is arriving faster than people can verify it

Kapur says coding agents have become widely used, while many developers report that generated code arrives too quickly to verify. Osmani says engineering leaders want to ship faster with confidence. He points to tests, benchmarks, and specifications as ways to decide whether code is high quality. Agents can now help create those checks more quickly. His advice is to give agents a way to verify their own work, then check whether the result is both correct and complete. Without that evidence, faster generation does not make shipping faster.

05:38

Anthropic combines Claude review with direct evidence from the user experience

Osmani says Anthropic increased its merged changes from about 2,500 in May to about 30,000 a day. Claude performs a first-pass review, but the review is expected to try the experience in ways similar to a real user. That can include end-to-end tasks, opening the product in a browser, running tools, linting, and other checks. Hooks inspect edits and diffs when a bug or functionality gap is found, so the pull request can be corrected quickly. Teams can also encode their practices in files such as Claude.md or agents.md. People then assess the evidence, including screenshots or videos for browser, mobile, and desktop behavior.

09:20

Verification needs concrete tests rather than a general instruction to check the work

Osmani says the next gains will come from better verification as well as better models. He names end-to-end tests, property tests, and visual verification tests as useful ways to build enough confidence for automatic merging. The question for teams is what verification actually means in their product. Saying 'verify the work' is too vague. Teams need to decide which tests expose the failures they care about and how those checks can provide evidence that an agent's change is ready.

11:48

Different verification layers catch different failures

Kapur recommends a zero-trust, multi-layered approach that verifies output inside every loop, including the agent loop, the continuous integration loop, and code maintenance. A deterministic layer can catch issues such as security problems, SQL injection, and buffer overflows. Agentic review can examine logic and intent, which deterministic checks are not well suited to assess. A software supply chain layer can check CVEs, malware, and malicious packages. Each layer has a different purpose, so one check cannot replace the others.

13:19

Autonomous agents need limits around identity, permissions, telemetry, and sandboxes

Osmani describes companies that allowed teams to create hundreds or thousands of agents without knowing what they were doing or which systems and data they could access. He says enterprises need to understand agent identity and telemetry, then focus on control, permissions, and the sandbox. The sandbox should prevent an agent from reaching systems or taking actions outside its task. Kapur calls these constraints 'guide rails' and says they should direct agents along an approved path while preventing them from going out of bounds.

14:41

Labeling agent-written pull requests preserves visibility while humans remain accountable

Osmani supports labeling pull requests written by an agent. He says the label can show which extra constraints and checks may be needed, while responsibility still belongs to the human owner. Kapur favors labeling for the foreseeable six to nine months, especially because financial customers need auditability. Osmani agrees that a person remains accountable even when they start a Claude run instead of writing the change directly. The label records how the change was produced, but it does not transfer ownership away from the engineer.

17:40

Autonomy has to be earned through independent checks in every factory loop

Kapur closes by separating fast code writing from fast shipping. Teams need strong review and verification, and they need to count and inspect what gets merged before it reaches production. He says every factory loop should contain independent automated verification so teams can trust its output. Osmani tells leaders to define the gap between their current testing practices and the evidence needed for an agent to sign off on a change. For junior developers, he recommends learning different forms of testing, including end-to-end and property tests.

"If you've got that in place and you can make sure that the code is both correct and complete, that can easily two to three by the quality of your outcomes."Addy Osmani05:03
Who should watch
  • Your team is merging agent-written pull requests faster than people can review them and needs a concrete verification process.
  • You are designing a light or dark software factory and need to decide where people, tests, and agent review belong.
  • You operate in a regulated environment and need auditability, access controls, and clear ownership for agent-written changes.