When Rootly's AI Agents Killed the Small PR Rule, Jiu-Jitsu Had the Answer

From the Mat to the Codebase

Every Jiu-Jitsu instructor I've had drilled the same mantra: respect the fundamentals. The closed guard, the basic sweep, the humble shrimp escape—these are the building blocks. But what happens when the game shifts? When a new guard player shows up who doesn't follow the old script? You adapt, or you get left behind. Rootly, an incident management platform, just learned that lesson the hard way in software development.

For two years, Rootly enforced a strict culture of small pull requests (PRs)—the coding equivalent of insisting every technique be a single, tidy movement. Quentin Rousseau, their CTO, explained that when humans write code, small diffs make sense. They're easier to review, easier to roll back, and they fit how our brains work. Then AI agents started writing most of the code, and everything changed.

The Old Guard: Why Small PRs Worked

Think of the traditional PR like a Jiu-Jitsu drill. You isolate one movement—say, a hip bump sweep—and you practice until it's smooth. You don't throw in a berimbolo, a leg lock, and a fancy back take all at once. That would be chaos. Small PRs operate on the same principle: keep the change minimal, focused, and easy to understand.

Rootly's rule was simple: stack PRs, keep atomic changes to a few hundred lines, and review everything carefully. It worked for two years. Human reviewers could keep up, and rollbacks were straightforward. The problem? AI agents don't think in increments. They think in features.

AI Agents: The New-Style Guard Player

If a human is a white belt writing code line by line, an AI agent is a black belt who can execute an entire sequence in one fluid motion. It generates the whole implementation—database migrations, models, services, controllers, tests, frontend components—all at once. It's like asking someone to demonstrate a full self-defense scenario, not just a single escape.

At first, Rootly tried to force AI agents to produce stacked PRs. The result? Technically correct code that was worse in context. Reviewers would look at one PR and find comments that depended on changes in another, forcing them to flip between tabs and reconstruct the bigger picture. It was cognitive overload. The small PR rule, designed for human efficiency, had become dead weight.

The Context Trap: When Technique Fails

Here's the kicker: AI-generated bugs are context bugs. The code runs fine—it's just applied in the wrong scenario. Rootly's engineering team gave an example: a database migration removed a field that a background job was still calling. Or a service wrote to a table that another team was reading. In Jiu-Jitsu, this is like drilling a wristlock that works on a compliant partner but fails against someone who knows how to frame. The technique isn't wrong; the context is.

This is why the old review process—looking at code line by line—misses the real danger. You can't spot a context bug by staring at syntax. You need to ask: if this change goes sideways, what breaks for the user?

Rootly's New Game Plan: Risk-Based Review

So, Rootly did something radical: they stopped reviewing AI code like human code. They built an internal AI code reviewer that evaluates every PR against engineering standards and produces a structured report—risk assessment, standardized score, confidence score, and a list of issues sorted by severity.

The key difference? It doesn't try to mimic a human reviewer. It asks one question: if this change has a bug, what user-facing features break? That's it. It classifies changes into two buckets: those that alter business behavior, and those that only affect performance or UI. Each gets a different risk level. Human reviewers get a map, not a raw diff.

This is like a coach who doesn't watch you drill every move, but instead watches how you react when the opponent throws a wild punch. What's the blast radius?

Feature Flags: Shifting the Safety Boundary

Rousseau emphasized that feature flags have moved the safety boundary from the merge stage to the release stage. Every important feature now ships behind a feature flag—it's off by default. The real review happens during progressive rollout: first internal, then a few customers, then 10% of users, then everyone. If something breaks, you flip the flag off. Rollback is instant.

In Jiu-Jitsu terms, this is like having a safety tap. You don't have to worry about tapping too early in practice because you know you can reset. The risk isn't in the technique itself; it's in how far you let it go before you tap.

And that's the point: the size of the code change no longer matters. What matters is the blast radius—how many people are affected if it fails.

The Industry Shifts

Rootly isn't alone. At QCon London 2026, Michael Webster talked about headless AI agents and how large AI-generated PRs create review bottlenecks and accumulate tech debt. Rewind, a backup and version control service, said its Diff Vader tool borrows Rootly's risk-based model. Their team wrote that a PR's risk has almost nothing to do with its line count.

Even Patrick Debois, often called the father of DevOps, joined a panel at the AI-Native Developer conference in June 2026 to discuss why PR-based workflows become an anti-pattern at agent speed. His take? PRs work in open source because contributors don't share strategic alignment and need to build trust. But inside a team with shared context and goals, when agents iterate fast, PR review cycles become hard to justify.

What This Means for Jiu-Jitsu

So, what does a software company's pivot have to do with Jiu-Jitsu? Everything, if you're paying attention. The core lesson is about adaptability. Rootly clung to a rule that made sense for a while, but when the game changed, they had to let go. The same happens on the mats. Maybe you spent years perfecting a certain guard pass, but then someone shows you a new way to play that makes it obsolete. Do you stubbornly keep drilling the old pass? Or do you learn the new guard and evolve?

And there's the question of review. In Jiu-Jitsu, we review our own technique constantly. We watch footage, we ask coaches, we try things in sparring. But if you're reviewing every detail the same way you did five years ago, you'll miss the context. The game evolves. New guards, new submissions, new counters. You need to ask: if I use this technique in a match, what's the worst that could happen? What's the blast radius?

Rootly's shift to feature flags mirrors the idea of progressive resistance in drilling. You don't go from zero to full resistance overnight. You start with a compliant partner, then add a little resistance, then more, until you're ready for a live roll. That's how you build confidence in a technique. And that's how you build confidence in a deployment.

Rollbacks Over Reviews

Rousseau concluded that abandoning the small PR rule was uncomfortable, but necessary to support their goal of 'shipping reliable software fast.' He wrote a follow-up article titled 'Stop Trying to Review AI's Code Faster: Bet on Rollbacks Instead.' The idea is simple: instead of trying to catch every bug in review, invest in your ability to undo the damage quickly.

In Jiu-Jitsu, this is like learning to escape from bad positions before you learn to submit. If you can escape from mount, you can survive a mistake. If you can roll back a bad deployment, you can survive a bug. The goal isn't to never make mistakes—it's to make them small and recover fast.

The Takeaway

The old way—handwritten code, small PRs, line-by-line review—was the best approach when humans were doing all the work. But now that teams are directing AI agents to deliver entire features, that model no longer applies. The same goes for Jiu-Jitsu. The techniques that worked in the past might not work tomorrow. The question isn't 'Is this the right technique?' but 'Is this the right technique for this situation, right now?'

So, next time you're on the mats, remember Rootly. Don't be afraid to throw out a rule that no longer serves you. Focus on the blast radius. And always have a plan for the rollback.