Providing a customer with high-quality code is one of the primary goals of any software development team. But the truth is nobody’s perfect, and whatever a developer’s level of proficiency and experience is, people do make mistakes.

Code review is a time-honored method that can help to detect errors and make your code nice and clean. What’s more, code review is not only about fixing bugs, it’s about building team cooperation. In this post, we’ll highlight the importance of code review and share our personal experience in practicing this. 


Code review: What it actually is

Well, the meaning is direct and clear: code review is reviewing the code against possible errors, misspells, bugs, and other mistakes. But despite the simplicity of this brief explanation, there are far more things hiding behind it. To get a better understanding of what code review is, let’s start by answering some relevant questions.

Who performs code review?  

That can be anyone on the team, other than the programmer who wrote this code. The idea is to look at a software program from the outside and give a clear-eyed assessment. So, any peer or peers can perform code review (so it’s also called peer code review), given that they are competent enough.

Why perform code review?

There are several reasons that make code review a crucial part of the software development process. Here’s what it’s good for:

  • Fixing errors that are currently present in the code and preventing problems that may appear in the future
  • Sharing knowledge between team members 
  • Boosting internal collaboration 
  • Brainstorming and finding nontrivial solutions
  • Keeping the codebase consistent
  • Ensuring the code’s compliance with all applicable standards, requirements, and style guidelines

How to do code review?

Every development team chooses their own approach to reviewing code and applies certain practices and tools that make this process efficient and convenient for them. There can be a manual review, an automated review, or a combination of both.

Manual code review is a time-taking process, during which a developer meticulously reads every single code line to find errors and impurities. While with automated code review, programmers are assisted by software tools that can check thousands of code lines in the blink of an eye. However, each of these methods has pros and cons, so to be on the safe side and achieve better results in your code review, you can use them both. 

In its turn, manual code review can be performed in different ways, including:

  • Pair-programming — the processes of coding and reviewing are simultaneous and occur at the same place as the reviewer sits next to the developer.
  • Over-the-shoulder review — the reviewer comes up to the developer’s workstation to check the code as soon as it’s written.
  • Email pass-around — the reviewer and developer exchange files, comments, and suggestions via email; in most cases, email pass-arounds rely on version control systems (VCSs) and are the top choice for remote and distributed teams.

Here, we focus mainly on the email pass-around code review, which offers a one-size-fits-all approach for various software development companies. However, the practices and tips that we share in this post can be successfully adopted in each of the above code review types. 


How to do it properly: Best code review practices

For starters, it’s necessary to define what exactly developers should look at when reading their teammates’ code. The list of things to consider includes but is not limited to:

✔ Logic

✔ Structure

✔ Naming

✔ Design

✔ Functionality


✔ Maintainability

✔ Automated tests

✔ Documentation

✔ Compliance with standards, requirements, and style guidelines

Now, let’s dive deeper into the code review process and see what steps you can take to test your code properly.

Step #1: Choose the right reviewer

Assigning the right person to perform a code review is the first step on the road to success. It goes without saying that a reviewer should have pertinent expertise and be more experienced than the developer whose code is under review. Alternatively, you can ask your teammates to join efforts and look at the code through the lens of their knowledge and skills. The main point is to find someone who is capable of contributing to the code by suggesting relevant changes and/or improvements.

Step #2: Heed the description

The first thing that is worth paying attention to in code review is the description of a merge request (MR) and commits. There’s no point in proceeding with code review if:

  • The MR has no description. 
  • The MR description conveys nothing.
  • There’s no reference to the ticket, in which the changes are performed.
  • Commits’ descriptions are bald (that is, one or two-word descriptions with no details).

If you can check off any of the above items, put the review process on hold and send the code back for rework.

Step #3: Mind the code

As you start looking at the code, pay attention to the MR size: it should be small. In case, the MR is big enough, it should be reworked and split into several smaller pieces. 

Then, you can go directly to the code review, sticking to the above-mentioned list of things to consider. For example, it’s important to make sure the code has a robust and reliable design so it couldn’t cause any problems for the project. The documentation must be updated and contain information about the latest changes made to the code. Remember to check the code’s style and the names the developer chose for variables, classes, etc.    

Code reviewers should reveal things that need adjustment or improvement by giving their opinion and suggesting a solution if there’s any. Or the reviewer can start a thread to organise a discussion and take a decision together with the developer who wrote the code.       

Step #4: Mark as resolved

After examining the entire code and adding all the necessary comments, the code reviewer should wait for the changes to be introduced by the developer. Once the changes are made, all comments must be marked as resolved by the commenter, not by the person who corrected the code. As soon as everything is resolved and approved, it’s the right time to merge the code.

Hands-on tips for code reviewers

Here are some handy tips that can help you to make the code review process a gain rather than a pain for everyone involved:

  1. ✔ Criticise fairly. The feedback you give should be constructive. In other words, don’t be personal and provide sound arguments and sensible reasons when commenting on the code.

  2. ✔ Maintain a friendly work environment. You are here not to blame others for their mistakes but to help your teammates to improve their expertise and become better professionals.

  3. ✔ Involve everyone. Encourage every team member to take on the role of a code reviewer and share their knowledge with others. Thus, you’ll kill two birds with one stone: get the code reviewed and improve teamwork.

  4. ✔ Don’t overdo. Performing manual code review requires strong attention to detail, while examining numerous code lines is a tedious process. So to stay productive as a code reviewer, you can break the whole process into short sessions, either time-constrained or limited by the number of lines

  5. ✔ Automate when possible. If some of the code’s features can be reviewed automatically (without compromising on quality), don’t miss a chance to save time and make your life easier.

  6. ✔ Play by your own rules. This means you can establish your own code review processes, using tools and approaches that are convenient to the entire team. These may include checklists, self-reviews, annotations, and so on.

How can you benefit from code review?

We have already mentioned the reasons why code review should become an integral part of the software development process. Now, let’s turn to the benefits of this procedure, either apparent or unobvious, that bring value to IT businesses and their clients.

Bug-free code

This is the number one benefit you can get from establishing the code review practice. When examining the code, a reviewer can identify errors or questionable issues. Thus, the code won’t be uploaded to a repository unless all bugs are fixed and issues are resolved. In addition, code review can disclose fault lines, such as subtle logic and inadequate test coverage, and protect against bugs in the future

Time and cost-savings

Code review performed at an early stage of the project can eliminate the need to fix problems at later stages, thus taking the load off QA engineers and accelerating project delivery. What’s more, correcting errors is much cheaper when you do it in good time, not when the solution is ready for production or falls into the hands of an end-user.

Code consistency

Developers can follow their own patterns and write code in a variety of manners, while by examining each other’s code, team members can draw on the pre-established standards. So the code review procedure can bridge diversities and make the code consistent throughout the overall company’s codebase. 

Levelling up skills

Code review is about sharing knowledge, adopting experiences, and, consequently, learning. This practice allows the team to exchange information, ideas, and techniques, which is important not only for juniors but also for senior engineers who can get a teammate’s opinion and look at the problem from a completely different angle. As a result, developers can hone their skills and improve performance. 

Better teamwork

Code review implies close collaboration between developers and thus can assist in strengthening professional and personal team relationships. When performed in a friendly manner, code reviews can facilitate mutual support and enhance trust between coworkers. All this makes a great contribution to building a high-performing team. 

Compliance with internal processes

Code review helps to verify the adherence to the company’s processes and workflows. By looking at their peers’ code, reviewers can check whether they are on the same page in terms of the project requirements and the way they should be implemented. Code review enables the team to document every detail to avoid misunderstanding or misinterpretation.


A quick recap

Code review is a testing procedure performed by a peer of the code’s author. This is a must-have activity for development teams aimed at creating bulletproof software solutions for their customers. 

Improved code performance, consistent codebase, reduced project time and budget, and better teamwork are just some of the benefits that you can gain from adopting the best code review practices that we share in this post.

Code review is an essential part of our development process that proved effective in delivering a variety of successful software projects created by the Mad Devs team. 

Explore the chapters