From small pull requests to blast radius: what AI agents change first
AI coding agents are software systems that autonomously plan, write, and validate code changes, often spanning entire features, and their rise is forcing engineering teams to replace human-optimized review habits like small pull requests with new standards focused on risk, blast radius, and automated verification. These agents do not work like human developers pacing through incremental commits; they produce complete implementations in one go, including migrations, models, services, controllers, tests, and frontend components in a single output. Holding onto a small-PR rule in that world is not prudent—it is denial. Incident-management platform Rootly has already abandoned its long-standing small pull request culture, arguing that the practice no longer serves its purpose now that AI agents generate most of its code. The uncomfortable takeaway is clear: the old mantra "smaller diff, safer change" breaks when machines write the bulk of your system.
Rootly’s experiment: stop treating AI like a junior developer
Rootly’s story should be a warning for every team still clinging to small-PR dogma. Its engineers discovered that forcing agents into stacked, tiny pull requests produced technically correct but contextually worse outcomes: review comments on one PR depended on decisions in another, and humans were stuck doing mental gymnastics across multiple tabs. The small-PR rule turned into overhead, not safety, because AI agents think in features rather than increments. Rootly’s response was blunt: stop reviewing AI code the way you review human code. They built an internal AI code reviewer that examines every PR against engineering standards and outputs risk assessment, standardisation score, confidence score, and findings grouped by severity. The key question it asks is not "is this diff small?" but "if this change has a bug, what user-facing behaviour breaks?". The company now uses feature flags and progressive rollout so the real review happens in production, with risk tied to blast radius rather than line count.
Parallel agents, self-hosted runners: workflow changes no team can ignore
The rise of multi-agent coding systems makes Rootly’s shift look less like an exception and more like the new normal. Meta’s Muse Code is pitched as “an agent for your most complex coding workstreams,” with multiple agents coordinating on each task: parallel workers doing implementation while reviewers run in the background. Muse Code installs with a single command and takes on complete software engineering tasks, including planning changes, writing code, and validating results. This is not a helper that tweaks a function; it is a factory generating large, intertwined changesets that human reviewers cannot reasonably treat as a series of tiny diffs. In parallel, Anthropic has opened a public beta of self-hosted environments for Claude Code, moving cloud sessions onto servers inside the customer’s own network. Sessions started from web, mobile, desktop, terminal, or scheduled routines run inside the organization’s network, next to internal services, toolchains, and security controls. That shift matters: repository checkouts, build artifacts, secrets, and any files a session creates or modifies stay on machines the organization provisions. Code review gates are no longer just about GitHub checks; they are about what your fleet of agents is allowed to do inside your own infrastructure.
HAR and deterministic validation: review the outcome, not the robot
Once you have multiple agents running in parallel, line-by-line review scales poorly and quickly turns into theatre. HAR was built from the pain of trying to scale agentic coding workflows and software factories, where “getting a single coding agent to work in a repo is easy” but “scaling to a real multi-agent workflow, where several runs at once and you still trust the output, is where it breaks down”. Its design is a direct critique of traditional review: each agent gets its own git worktree, branch, ports, and database, so a fleet can run without colliding on a dev server, database, or ports. More importantly, HAR introduces deterministic validation gates, running a project’s real checks through a fixed pipeline and binding the result to the exact code that passed, enforced at commit time so an unverified tree cannot land. Every run leaves logs, artifacts, and a validated tree hash tied to the exact code checked, turning review into inspection of evidence rather than trust in an agent’s self-report. This is the direction Rootly’s AI reviewer also points: stop pretending humans can sanity-check every line and instead build systems that tie changes to verifiable behaviour.
Co-trained agents and new standards for automation-first code review
The next twist is that AI coding agents themselves are becoming more consistent and specialised, which raises the bar on how teams evaluate them. Meta shipped Muse Code in beta alongside Muse Spark 1.2, a version of its flagship model that it says was co-trained with the agent for tighter integration. Because Muse Code and Muse Spark 1.2 were co-trained, the pairing produces better tool use, fewer retries, and higher-quality output than a generic wrapper around an outside model. The underlying model is optimised for real coding workflows with higher first-attempt accuracy and more reliable tool calling. On Anthropic’s side, self-hosted Claude Code sessions can reach internal services, databases, and registries without exposing them to the public internet, and teams can pre-install compilers, SDKs, and internal command-line tools so every session starts ready to build. “Self-hosted environments let us integrate Claude Code into our existing development workflows while maintaining our security and operational controls,” said George Jacob, senior engineering manager at Faire. When agents are this deeply integrated and consistent, code review automation stops being optional hygiene. It becomes the only realistic way to manage developer workflow changes, from blast-radius assessment to outcome verification across multi-agent coding systems.
