When AI Rewrites the Rules of Code Review: A Paradigm Shift in Software Development
What happens when the sacred cow of software engineering—small, atomic pull requests—gets tossed out the window? The answer, it turns out, lies in the collision between human habits and AI-driven efficiency. Rootly’s recent decision to abandon its strict small-PR policy isn’t just a minor tweak to their workflow; it’s a symptom of a deeper transformation in how we build software. Let me unpack why this shift matters—and why it’s both terrifying and exhilarating.
The Death of Line Counts: Why Smaller PRs Were a Human-Centric Lie
For years, engineering teams have treated small pull requests like gospel. The logic was simple: smaller diffs mean easier reviews, faster rollbacks, and fewer bugs. But here’s the dirty secret—this rule was born in an era when humans wrote code by hand, line by line. As Rootly’s CTO Quentin Rousseau admits, small PRs optimized for human limitations now feel like cargo culting in the age of AI. When an agent spits out a complete feature—database migrations, backend services, frontend components, and tests—all in one go, obsessing over line counts becomes performative. In my opinion, this reveals a critical blind spot: we’ve been measuring the symptoms of code quality (size) instead of the root causes (context, risk, and reversibility).
AI Bugs Aren’t Bugs—They’re Contextual Misunderstandings
What makes AI-generated code so different? It’s not just the volume; it’s the nature of the errors. Human bugs are often syntactic or logical. AI bugs are existential. A migration that drops a column still used by a background job? That’s not a typo—it’s a fundamental misunderstanding of the system’s architecture. Rootly’s engineering team nails it: AI works correctly but on the wrong assumptions. This flips code review priorities. Instead of hunting for typos, reviewers now grapple with systemic risks. Personally, I think this highlights a paradox: the more powerful our tools become, the harder it is to control their side effects.
Feature Flags and the Rise of the Safety Net Economy
Rootly’s solution? Move the safety boundary from merge to rollout. By shipping features behind flags and progressively enabling them, they’ve turned production into the ultimate testing ground. From my perspective, this mirrors the fintech revolution of “ship first, verify later” with real-time fraud detection. The difference? Software teams now have the luxury of treating rollbacks as first-class citizens. What many people don’t realize is that this approach only works if you’ve baked reversibility into your culture—and your infrastructure. Teams that cling to pre-merge perfection are fighting the last war.
The AI Reviewer: Not a Replacement, But a Risk Translator
Here’s where it gets wild: Rootly built an AI code reviewer that doesn’t even pretend to be human. Instead of nitpicking style guides, it asks the existential question: “If this breaks, what user-facing behavior dies?” This isn’t automation—it’s translation. The AI converts raw code changes into a risk profile, separating “this alters business logic” from “this tweaks a CSS class.” I find this fascinating because it acknowledges AI’s strengths (pattern recognition) while compensating for its weaknesses (contextual awareness). Human reviewers no longer drown in diffs; they get a structured risk report. It’s like giving a layperson a cheat sheet for reading a foreign language.
The Bigger Picture: PRs as Process Waste in the Agent Era
But wait—should we even be using pull requests at all? DevOps godfather Patrick Debois argues that PRs are relics of open-source collaboration, not modern teams. Inside organizations with shared goals, the overhead of PR cycles starts to feel absurd when AI agents work at “agent speed.” What this really suggests is that our tools are forcing us to confront inefficiencies we ignored for decades. And let’s not forget the financial angle: token costs make waste painfully visible. Suddenly, every redundant review isn’t just a time sink—it’s a line item on the bill.
The New Metric: Blast Radius Over Line Count
At the end of the day, Rootly’s story teaches us one thing: the blast radius is the only metric that matters now. A 2,000-line PR that toggles off a non-critical feature is safer than a 10-line config change that breaks authentication. This raises a deeper question: If AI can write code faster than we can review it, what does “engineering excellence” even mean? My bet is on teams that master two skills: designing reversible systems and asking the right “why” questions. Because here’s the kicker—AI can’t explain why a change is urgent or what business goal it serves. That human context is the last mile of software delivery.
Final Thoughts: Embracing the Uncomfortable Future
Dropping the small-PR rule felt “uncomfortable but necessary” for Rootly. That tension captures the AI revolution in a nutshell. We’re all clinging to familiar rituals—code reviews, PR templates, style guides—while the ground shifts beneath our feet. The companies that thrive won’t be the ones who perfect AI-generated diffs. They’ll be the ones willing to rethink why they review code at all. Because if you take a step back and think about it, the real story here isn’t about pull requests. It’s about surrendering control to gain speed—and building safety nets strong enough to catch the falls.
