How Code Reviews Should Work
If you’ve ever opened a pull request, crossed your fingers, and hoped for a quick “LGTM,” you’re not alone. Code reviews are a standard part of writing software, and often one of the most frustrating.
When they go well, reviews are fast, thoughtful, and help you ship better code. When they don’t, they drag on, full of nitpicks and vague comments, and no one’s sure what’s actually being reviewed.
Let’s talk about how code reviews should work, and how to make them better for everyone involved.
Caparra does not recommend squirrel-based code reviews.
The Two-Pass Reality
Most reviewers won’t admit it, but code reviews usually happen in two passes.
Pass One: The Surface Check. This is the quick first look. Reviewers skim through the code and look for things like:
Are variable names clear?
Is the code formatted consistently?
Does it follow the team’s style guide?
Are there obvious typos or commented-out chunks?
At this point, the reviewer isn’t diving deep. They’re just seeing if the code “looks right.” It’s a natural instinct, and it’s not a bad one… after all, clean code is easier to understand. But if this first pass finds too many issues, it can block meaningful feedback from happening.
Pass Two: The Deep Dive. Now we’re getting into the good stuff:
What does this code actually do?
Is the approach sound?
Are edge cases covered?
Is anything likely to break in production?
This second pass is where the real value of a review lives. It’s where you catch logic bugs, improve design, and help teammates learn from each other. But here’s the catch: if reviewers get bogged down in formatting issues during the first pass, this deeper review might never happen.
The Fix: Let Tools Handle the Tedious Stuff
Here’s where modern development shines. You don’t need to rely on humans to catch spacing errors or inconsistent imports. Tools like Black (for formatting Python code) or Ruff (for linting) do that automatically and instantly.
When you run a formatter or linter before opening your pull request:
The code looks clean from the start
Reviewers can skip the small stuff and jump straight to functionality
Feedback is more useful
Everyone’s less annoyed
It’s not just about saving time. It’s about respect. You’re showing that you’ve done your part to make your reviewer’s life easier. And in return, they can give you better feedback, faster.
Clean Code Makes Better Reviews
There’s a well-known idea in DevOps called “shifting left.” All it means is: do important checks earlier in the process, before things pile up downstream.
In the world of code reviews, this means handling the basics yourself. Before asking someone to look at your pull request, you should:
Run your formatter and linter
Write (or update) relevant tests
Add a short comment if your design choice might be surprising
Make sure the code is easy to read, even for someone who wasn’t part of the original conversation
When reviewers aren’t distracted by little issues, they can focus on what actually matters: Does this code work? Is it the right approach? Is there a simpler way?
That’s where the magic happens.
Reviews Should Be a Conversation, Not a Gatekeeping Ritual
The best code reviews feel like collaboration, not judgment. They’re an opportunity to ask questions, learn from each other, and improve your system as a team.
When the small stuff is already taken care of—by tools or by the author—there’s space for that conversation to happen. You can talk about trade-offs, performance, clarity, maintainability. And you’re not wasting your energy reformatting lines or debating quote styles.
If you’re a reviewer, look for ways to be generous with your feedback. If you’re the author, make it easy to say yes.
Getting on the Same Page
So hopefully we’ve sold you on the benefits of formatting and linting your code before you hit “Create Pull Request.” But does everyone on your team have the same definition of what good looks like? Or do you default to “whatever the senior dev likes?”
At Caparra, we’re building tools that help your team define what good looks like, also known as engineering standards. When your team defines these standards, it gives everyone a clear vision to act independently, without waiting for approvals. Caparra will also help you enforce these standards, by bringing your existing code up to standards, and running pre-commit checks automatically.
If that sounds good to you, open a free Caparra account. It’s a great way to get started building smarter, faster, and with fewer code review headaches.
