Why Competitive Swimming Coaches Should Rethink the Small PR Rule

The Old Rule That Made Sense

For years, competitive swimming coaches have preached the gospel of small, incremental changes. Break down the stroke, fix one flaw at a time, drill it until it's automatic. It worked when humans were doing the swimming—and the coaching. But the sport is changing. AI-powered training systems now generate entire practice plans, race strategies, and technique overhauls in one shot. The old rule—keep every practice change small—starts to feel like a relic.

Rootly, an incident management platform, recently explained why they abandoned their long-standing "small pull request" rule. Their CTO, Quentin Rousseau, wrote that for two years they enforced a strict culture of small PRs, using stacked PRs and limiting atomic changes to a few hundred lines. It made sense when humans wrote code. Smaller diffs are easier to review and roll back. But AI agents changed the equation. They think in features, not increments, and can output a complete implementation—database migrations, models, services, controllers, tests, frontend components—in one go.

When the Big Picture Breaks

In swimming, an AI coach might design a full season plan in one fell swoop. It looks perfect on paper. But the context matters. A drill that works for a sprinter might wreck a distance swimmer's pacing. A new turn technique might shave seconds off a breaststroke leg but cause shoulder strain in butterfly. The AI doesn't see the context—it just sees the swimmer's times and stroke metrics.

Rootly's engineers described the same phenomenon. AI-generated code isn't technically wrong; it's contextually wrong. It runs fine but gets used in the wrong scenario. A database migration deletes a field that background jobs still call. A service writes to a table that another team is reading. The code works, but it breaks the system's overall behavior.

Stacked PRs and the Mind-Bending Review

Rootly tried to force AI agents to generate stacked pull requests—small, sequential changes. The result? Code that was technically sound but made less sense in the broader business context. Reviewing one PR required jumping to another PR to understand the rationale, forcing reviewers to flip between pages and track multiple threads. The mental load exploded.

It's like trying to review a swimmer's new stroke by watching only the arm pull in isolation, without seeing how it connects to the kick, the breathing, and the turn. You can't evaluate the change without the whole picture. The small-PR rule was designed for human efficiency. AI broke that efficiency ceiling, and the old rule became just overhead.

Stop Reviewing Like a Human

Rootly's solution was to stop reviewing AI code like it was human code. They built an internal AI code reviewer that examines every PR against engineering standards and produces a structured report: risk assessment, a standardized score, a confidence score, and a list of specific issues sorted by severity. The key difference? It doesn't try to play the role of a human reviewer. Instead, it answers one question: if this change has a flaw, which user-facing features will it break?

In swimming terms, that's like asking: if this new drill set has a flaw, which race performance will it hurt? The AI reviewer distinguishes between changes that alter actual business behavior and those that only affect performance or UI. It assigns risk levels accordingly, giving human reviewers a structured reference instead of a raw diff.

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, default off. The real review happens during progressive rollout: enable it for the team, then a small group of customers, then 10% of users, then everyone.

That's a smart approach for swimming too. Don't overhaul a swimmer's technique in one dramatic practice. Ship it behind a metaphorical flag: try it in a low-stakes workout, then a practice meet, then a local competition, then a championship. If it fails, you can roll back by reverting the flag—no permanent damage.

For Rootly, the size of the code change no longer matters. What matters is the blast radius—the potential impact if the change goes wrong. In swimming, that means asking: if this new training plan fails, how many swimmers are affected? How many race results might suffer? That's the real risk metric.

The Cost of AI Tokens and Process Waste

At the 2026 London QCon, Michael Webster discussed headless AI agents and their impact on software delivery. He noted that large AI-generated PRs create serious bottlenecks for human reviewers and accumulate technical debt. Other companies echo this. Rewind, a backup and version control service, said their code review tool Diff Vader borrows Rootly's risk-based model. A PR's risk has almost nothing to do with its line count.

In the swimming world, the cost of AI is quantifiable too. AI-generated training plans consume tokens, and every wasted drill set or misguided technique change shows up in the swimmer's times or injury rates. As Patrick Debois (the "DevOps father") pointed out, PR workflows become an anti-pattern in teams with shared context and goals. In open source, PRs build trust among strangers. But inside a team with common objectives, when agents iterate fast, the review cycle becomes hard to justify.

The same goes for swimming squads. If the coach and the AI share the same context—the team's goals, the swimmers' strengths and weaknesses—then forcing every change through a rigorous review process might just slow things down. You need a review, but it should be risk-based, not size-based.

Asking the Right Questions

Rootly's new philosophy is to ask questions that truly predict production incidents. The "why" and "what" sections of a PR require developers to explain the motivation, scope, and potential impact. For AI-generated PRs, the human who uses the agent fills these out. Rootly explicitly tells AI assistants not to generate these sections, because the purpose is to capture context: why this change, why now, what business need does it address. Every PR must describe how to safely roll back, including necessary data fixes.

In swimming, that means every new training block should come with a rationale and a rollback plan. If we're introducing a new pacing strategy, why are we doing it now? What's the competitive goal? How do we revert if it doesn't work? That kind of context is what makes a review meaningful, not the number of lines changed or the size of the drill set.

Rousseau admitted that killing the small-PR rule—a process that once felt so right—was uncomfortable at first. But it was necessary to support "fast delivery of reliable software." In another article, he expanded on this shift toward production safety: "Stop Trying to Review AI's Code Faster: Bet on Rollbacks Instead."

The Bottom Line for Swimming

The takeaway for competitive swimming is clear: in the era of human-written training plans, small, incremental changes were the gold standard. But now that we're delegating whole features to AI agents, that rule no longer applies. What matters is the blast radius, the context, and the ability to roll back safely.

So, coaches, don't get hung up on the size of the change. Ask the right questions. What could this break? How do we revert if it does? And maybe, just maybe, let AI write the whole season plan—just keep the feature flag handy.