How to Conduct Code Reviews for Remote Teams

In the last 11 years of my career, I’ve participated in code reviews almost daily. I’ve sat through 100s of review sessions with seniors and colleagues. Here’s how to make your code reviews smoother, faster and easier: 1. Start with Small, Clear Commits    - Break your changes into logical, manageable chunks. This makes it easier for reviewers to focus and catch errors quickly. 2. Write Detailed PR Descriptions    - Always explain the “why” behind the changes. This provides context and helps reviewers understand your thought process. 3. Self-Review Before Submitting    - Take the time to review your own code before submitting. You'll catch a lot of your own mistakes and improve your review quality. 4. Ask for Specific Feedback    - Don’t just ask for a “review”—be specific. Ask for feedback on logic, structure, or potential edge cases. 5. Don’t Take Feedback Personally    - Code reviews are about improving the code, not critiquing the coder. Be open to constructive criticism and use it to grow. 6. Prioritize Readability Over Cleverness    - Write code that’s easy to understand, even if it’s less “fancy.” Simple, clear code is easier to maintain and review. 7. Focus on the Big Picture    - While reviewing, look at how changes fit into the overall system, not just the lines of code. Think about long-term maintainability. 8. Encourage Dialogue    - Reviews shouldn’t be a one-way street. Engage in discussions and collaborate with reviewers to find the best solution. 9. Be Explicit About Non-Blocking Comments    - Mark minor suggestions as “nitpicks” to avoid confusion. This ensures critical issues get addressed first. 10. Balance Praise and Criticism    - Acknowledge well-written code while offering suggestions for improvement. Positive feedback encourages better work. 11. Always Follow Up    - If you request changes or leave feedback, follow up to make sure the feedback is understood and implemented properly. It shows you’re invested in the process. -- P.S: What would you add from your experience?

You're doing it wrong: Engineering Design or Software Code Reviews Yesterday, someone asked me the one single thing I do with engineering teams to have the fastest impact. That thing is changing the mindset around engineering design reviews or software code reviews. Most people spend their time doing very low-value nitpicks in code reviews: "Can you update this note in the drawing?" or "This indentation is a bit weird on line 223". Those things are important and reviews are a great place to catch them, but they aren't the most important thing. The biggest value of any review is to check whether the change or design meets the intention. That is something that automated tools can't check and is also the number 1 reason why engineering changes fail in the field: the design didn't meet the intention or the intention was wrong. To do this, I coach reviewers to do the following when they look at a review: 1. Check whether they understand the intention of this change or design. There isn't a "correct" way to document this, but it should be documented somewhere (requirements, design doc, in person meeting, etc). 2. Does the reviewer believe the intention to be correct? If not, have some discussion on the intention before even looking at the design 3. Look through the change or design. Do you think this meets the intention? Does it meet the intention under all reasonable circumstances? Are there scenarios or circumstances where it might not? 4. Is there sufficient analysis or test evidence to convince you that this design or change will actually meet the intention in practice, not just on paper? If not, is there a plan to verify this before production and roll it back if not? 5. Then get into the design details :) Asking reviewers to follow this basic process starts to immediately and radically change the engineering culture of any team. Reviewers stop feeling like robots and turn on their creative brain to solve hard challenges. #engineering #codereview #designreview

A common mistake of developers new to a "tech lead" role: trying to perform every code review. They're concerned that something will break if they don't. But reviewing every pull request isn't feasible, and doesn't scale. What to do instead? Here's what I've learned: 1️⃣ Enhance your delivery systems outside of code review. Strengthen your release pipelines with tests, monitoring and rollback. This will help to prevent, detect and mitigate defects. 2️⃣ Document code review processes. Team members should be aware of the expected size, scope and structure for each PR. Add automated checks for testing and approval. 3️⃣ Establish paradigms. Introduce design patterns and structure to the codebase, that others can leverage and build on top of. 4️⃣ Integrate automated tools. Use linters and formatters to ensure consistent style. Set up automated static code analysis. 5️⃣ Teach your team to review effectively. Emphasize the importance of kindness, clarity, and thoroughness. Identify when blocking is or isn't appropriate. 6️⃣ Be aware of what's going out. Slack/GitHub integration works well. Know when to scan a pull request, and when to do a thorough dive. You can't write and review all the code for your team. If you could, hiring others would be pointless. Instead: put your team in position to ship better software, faster. 🚢 #softwareengineering #codereview

When I was a developer, I participated in a lot of code reviews, on both sides. Most participants either gave tepid feedback for fear of offending the author of the code or overly harsh feedback in an attempt to be honest or to maximize quality. Pointed, kind, useful feedback was rare. Peter Green and I were talking today about how the Humanizing Work Early Feedback Process would have worked so much better than the typical code review approach. Here's how it would look... 0. Kickoff — Share the goal of the meeting and the approach you're going to use 1. Context — The author of the code explains the larger context in the application, what the code is supposed to do, and what state it's in. 2. Content — Show the code. 3. Questions — Reviewers ask clarifying questions that will help them evaluate what they're seeing and provide useful feedback. They should be careful not to give advice or opinions masquerading as questions.  4. Kudos — Reviewers highlight what they particularly like in the code. 5. Comments — Reviewers share opinions and advice. Avoid debate about the opinions and advice, and avoid turning this into a decision-making step. 6. Conclusions — Finally, the author of the code summarizes what they heard, any key takeaways, and what they intend to do with the feedback. We've been using this process for all kinds of work-in-progress on our team and it has been surprisingly useful and fun.