Umamaheswaran

Code reviews are an essential part of software development, yet many of us approach them with an “LGTM” (Looks Good to Me) mindset. While this may seem sufficient on the surface, it often results in missed opportunities to improve code quality, enhance team dynamics, and foster collaboration. Let’s delve into the common pitfalls in code reviews and discover actionable steps to make them more effective for both reviewers and authors.

What is LGTM, Really?

“LGTM” has become a shorthand for quick approval in code reviews. But does it truly mean the reviewer has given due diligence? Often, it signals a rubber-stamp approval that skips over potential issues, creating risks for the project.

Common Reviewer Mistakes

Here are some of the biggest mistakes reviewers make—and how they can negatively impact the code review process:

1. Ego-Driven Reviews: Some reviewers see code reviews as a competition to prove their intelligence or superiority, which creates a toxic team dynamic.
2. Focusing on Developers, Not Code: Comments that target the individual rather than the code are often perceived as toxic, leading to resentment.
3. Skimming Through Reviews: Treating small PRs with excessive scrutiny while skimming over large ones undermines the process.
4. Ineffective Comments: Ambiguous or subjective feedback leaves authors guessing, causing unnecessary delays.

How to Be a Better Reviewer

To elevate your role as a reviewer, follow these tips:

1. Leave Your Ego at the Door: Focus on the code, not on proving your expertise.
2. Conduct Proper, Thorough Reviews: Work in 25-45 minute focused sessions to give the code your full attention.
3. Write Effective Comments: Be specific, objective, and outcome-focused. Use the “Triple R” pattern:
   • Request: What change is needed?
   • Rationale: Why is the change necessary?
   • Result: What should the end state look like?

Common Author Mistakes

Authors aren’t exempt from responsibility. Here’s what they often get wrong:

1. Skipping Self-Review: Many authors fail to review their own code before submitting it.
2. Ignoring Automation: Neglecting tools like linters, formatters, and automated tests creates avoidable issues.
3. Unmanageable PRs: Large pull requests or ones lacking context make reviewers’ jobs harder.
4. Treating PRs as Mystery Novels: Providing little to no description forces reviewers to play detective.
5. Tying Personal Worth to Code: Taking feedback personally creates a defensive atmosphere.

How to Be a Better Author

Improve your pull requests with these best practices:

1. Be Your Own First Reviewer: Review your code as if you were the reviewer. Draft incomplete PRs if needed.
2. Use Automation: Linting, static analysis, and automated testing catch low-stakes issues early, allowing reviewers to focus on higher-value feedback.
3. Make PRs Manageable: Keep pull requests small, focused, and easy to understand. Provide clear descriptions and context.
4. Separate Yourself from the Code: Accept feedback objectively to improve the code, not take it as a critique of yourself.

Going Beyond the Basics

Once you’ve mastered the fundamentals, consider these advanced strategies:

• Create a Teamworking Agreement: Establish guidelines for the code review process, including PR states, blocking issues, and more.
• Use PR Templates: Provide authors with checklists tailored to different types of pull requests.
• Auto-Assign Reviewers: Leverage tools like GitHub Code Owners to ensure the right people review the code.
• Encourage Code Compliments: Highlight innovative solutions or impressive improvements to foster a positive team dynamic.
• Add Informational Reviewers: Assign junior team members or newcomers as optional reviewers to spread knowledge and eliminate silos.

Key Takeaways

Code reviews are more than a formality—they are an opportunity to improve both code quality and team collaboration. By avoiding common mistakes, adopting better practices, and striving for a culture of constructive feedback, you can turn code reviews into a powerful tool for team growth.

Let’s move past the bare minimum. Strive for reviews that are productive, collaborative, and, most importantly, meaningful. After all, great code reviews lead to great code—and great teams.

References

https://www.manning.com/books/looks-good-to-me