Prioritize code reviews to ship faster

Note: This is an adaptation of a talk I gave to the Growth Engineering team at Squarespace in 2024.

In product engineering, a common question teams face is the seemingly elusive one, “Why is it taking so long to get this feature out?”

It’s been my experience that the answer most often lies not in big decisions, but in small inefficiencies that build up over time.

One of the most impactful yet overlooked factors is how teams manage code reviews.

Why Code Reviews Matter

Code reviews are crucial for accelerating your team’s ability to ship features.

In an ideal world, we wouldn’t need code reviews at all. We’d have a system that ensures code is always in a state that is ready to be shipped, all conventions are followed, and the entire team has all the context they need to own and maintain those changes far into the future.

Unfortunately, we don’t live in an ideal world.

As an organization scales, it becomes harder to ensure the team is aligned and that best practices are being consistently applied.

Code review serves as a critical inflection point in the development process. It shares context between team members, and catches bugs that might otherwise slip through the cracks.

But it’s not just about doing code reviews; it’s about doing them right, and understanding that the goal of writing code is to ship products, not naval gazing over the craft of engineering. With that in mind, expedience is key.

Delays in reviews often block progress, as tasks can’t move forward without approval. When engineers are blocked, they either have to context switch to other tasks (which slows them down) or wait for reviews, stalling their work completely.

The Cost of Context Switching

Context switching—moving from one task to another—costs time and energy. Research shows that switching between tasks increases stress, errors, and slows down overall productivity. In software engineering, switching between writing code and reviewing code is expensive. But, strategically, this type of context switching can still be valuable for the team’s overall velocity if in the service of prioritizing reviews.

Why Prioritize Code Reviews?

When reviews are delayed, it blocks the entire team. Features can’t be completed until they’re reviewed, and pending reviews prevent new work from starting. This is especially true in teams with serialized workflows, where tasks depend on one another. By prioritizing code reviews, you remove bottlenecks and speed up the entire team’s progress.

Code reviews represent blocked threads. The most important thing for any team is to land the work that is closest to completion, and that is the work that is in review.

Tips for Code Reviewers

1. Know Your Review Queue: Always be aware of which PRs you need to review. Set up notifications (e.g., via Slack or GitHub) so you don’t miss anything.

2. Review Frequently: Aim for short, frequent review sessions throughout the day. Don’t let reviews pile up—clear your review queue regularly.

3. Prioritize Reviews: Treat reviews as top priority over writing new code. If reviews are delayed, progress stalls for everyone.

4. Be Thorough and Respectful: Make your feedback detailed, actionable, and kind. Don’t just give a simple “looks good to me” if you haven’t checked everything thoroughly.

Tips for Code Authors

1. Write Well-Prepared PRs: Before submitting a pull request, ensure your code is clean, well-documented, and follows project guidelines. Treat your code like it’s someone else’s.

2. Keep PRs Small: Large PRs are harder to review and more likely to contain bugs. Break them down into smaller, more manageable chunks to make reviews faster and easier.

3. Provide Clear Descriptions: A well-written PR title and description help reviewers understand the context and purpose of your changes, making the review process smoother.

4. Respond Quickly to Feedback: Acknowledge comments and make changes quickly to keep the review process moving forward.

To ship faster, make code reviews your top priority. Not only does this reduce bottlenecks and improve team velocity, but it also minimizes the costs associated with context switching and unblocks your team. Focus on getting work from “in progress” to “done” rather than just starting new tasks. By optimizing the code review process and making it a seamless part of your daily workflow, your team can deliver work faster and with higher quality.