When I first got into the habit of reviewing code, I thought I had it figured out. After all, code reviews are just about making sure things work, right?
How little did I know how wrong I was.
My attitude to code reviews wasn't just inefficient, it was damaging: it irritated colleagues, fomented resentment, and delayed feature launches, all for failing to stick to some really simple yet powerful unwritten rules of code reviews.
Here are the 4 rules I learned the hard way:
1. Block a PR Only If It Requires Your Approval
We've all been there: you click "Request Changes" because something seems off, or you don't like some implementation detail. It sounds harmless-after all, it's just a request, right?
Wrong.
Where you "request changes," that action often halts the entire process. And let's be real: there's a reason it's written in red.
So unless the change being requested is literally the only thing preventing you from advance with a bug or security vulnerability or something imperative, don't block the pull request.
Suggestions are well and good, but over-zealously blocking PRs gets in the way of frustrating your peers and slowing them down.
2. Show Don't Tell
I have no idea how much time I wasted typing away explaining changes with long paragraphs when a code snippet would do.
Instead of writing "You should refactor this section to be more DRY," you can simply write the refactored code and paste it in the comments. It's quicker and easier, and helps the developer understand your point straight away. Code is the common language we all understand, so use it to your advantage.
3. Give Critical Feedback In Person (or Via a Slack Huddle)
There is nothing worse than getting back a five-paragraph essay tearing your code apart. Code review platforms are great for comments, but can often strip out much of the nuance that a conversation provides.
If you need to provide critical or serious feedback, it's best to talk about it in person or through a quick Slack huddle. That way, it's much easier to convey your tone and avoid misunderstanding. Moreover, with a direct yet respectful conversation, you are less likely to bruise an ego.
4. Review the Big Picture First
It's tempting to dive into the details-after all, nitpicking code is what we love doing! But before you get into the small stuff, take a step back. Look at the high-level changes:
- Are there any API changes?
- Is the database schema being modified?
- Do the changes impact overall architecture?
Focusing on the big-picture stuff first helps to identify the potential blockers earlier on. As for the small stuff - those minor refactors, naming conventions, or unit tests ,they often can be cleaned up later.
As a matter of fact, those little details could well change based on larger discussions about the big picture anyway.
The Most Important Rule: Everyone Has a "Nit Limit"
Everyone has a limit in terms of how much nitpicking they are willing to tolerate. We all want to improve our code, but we all reach a stage where too much feedback turns into resentment. People won't always be open about their feelings of frustration, and they might not even be aware that it's happening in their brain, but the more nitpicks you do, the less they'll care about your feedback.
So, pick your battles. Don't die on a hill for that one extra line of spacing or whether to use a const instead of a let.
When you approach code review, bring curiosity and empathy. Try to understand why the author decided on one thing over another. Most of all, this holds true if you will be the maintainer of this code later. Instead of "this is wrong," start off by "why." Understanding of trade-offs is key in software development.
Conclusion: Give Helpful, Respectful Feedback and Everyone Wins
Code reviews are about so much more than finding mistakes at the end of the day. It's about collaboration, improvement, and making sure we're all building something maintainable. If done right, code reviews can build trust, solidify team cohesion, and ultimately drive better results for us all.
