# How to Do Code Reviews Better | LinearB Blog

> Code reviews have become a vital part of the software development process. They improve code quality, developer performance, and save development teams time. But only when done correctly. So what does a good code review look like? Why is it so important? And can any part of the process be automated? To answer these questions, […]

_This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._


```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://linearb.io/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://linearb.io/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "How to Do Code Reviews Better",
      "item": "https://linearb.io/blog/how-to-do-code-reviews-better"
    }
  ]
}
```

[Home](https://linearb.io/)

/

[Blog](https://linearb.io/blog)

/

How to Do Code Reviews Better

# How to Do Code Reviews Better

![Photo of Brandi M.](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/logo-mark-lg?_a=BAVMn6ID0)

By [Brandi M.](https://linearb.io/blog/how-to-do-code-reviews-better#brandi-m)

|

March 17, 2022

![How_to_do_a_code_review_1a24e93efa](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/How_to_do_a_code_review_1a24e93efa?_a=BAVMn6ID0)

Code reviews have become a vital part of the software development process. They improve code quality, developer performance, and save development teams time. But only when done correctly. 

[So what does a good code review look like](https://linearb.io/blog/code-review-on-github)? Why is it so important? And can any part of the process be automated? 

To answer these questions, let’s look at the best ways you and your team can handle code reviews.

## Table of Contents

* [Code Review Definition](#definition-of-code-review)
* [Main Issues a Code Review Process Solves](#main-issues-code-reviews-solve)
* [Give Your Reviewers Context](#reviewer-context)
* [Keep the Code Changes Small](#small-changes)
* [Give Constructive Feedback ](#constructive-feedback)
* [Include All Team Members in Your Code Review Process](#include-all)
* [Automate to Improve](#automate-improve)
* [Measure & Iterate on Your Code Review Process](#measure-iterate)
* [Best Practice and the Right Tools: A Perfect Combination](#best-practice-and-the-right-tools-a-perfect-combination)

## **Code Review** Definition

A [code review or peer code review](https://linearb.io/blog/what-is-code-review-why-its-important-for-code-quality) requires one or multiple team members to check another team member’s work. You need to review any changes made to the source code before implementing them into the codebase. Doing so will improve code quality and help programmers work in collaboration. 

## **Main Issues A Code Review Process Solve**s

### Code Quality

Are you looking for a checklist to standardize your PR process and fix code quality issues? This happens because too many developers merge their code without review, or the review depth is a single comment that says, “Looks good to me,” without any real feedback. 

Establishing a code review process and reinforcing it with your team, should improve your code quality and reduce rework or code churn.

### High Cycle Time

Another important problem that a review process solves is preventing bottlenecks in your software development lifecycle and [reducing cycle time](https://linearb.io/blog/how-to-reduce-cycle-time-in-software-delivery). Code reviews typically have lots of idle time and severe context switching. 

Remember that cognitive load increases when revisiting code. The longer it has been since a developer wrote the original code, the harder it will be for them to regroup their thoughts and get in the state of flow. 

This creates idle time as a developer tries to re-read what they have written before revising the code. Therefore, both context switching and idle time are the biggest productivity killers in the code review process. 

So let’s look at six steps you can implement into your code review process to ensure your software engineering team is reaching its full potential with code quality and cycle time.

## **Give Your Reviewers Context**

By default, code reviews cause context switching, but if you can supplement the review with context, the reviewer will be able to make better decisions and potentially have to switch context fewer times. 

As you go into review the lines of code, you must know what to look for. For example, a reviewer might ask themselves these questions: 

* Do you understand what the code is supposed to do?
* Does the code work as you expect it to?
* Does the code fulfill all regulatory requirements?

Answering these questions requires them to go to Jira or whatever project management tool you use to read about the issue. 

We’re on a mission to keep developers from ever having to log into Jira again. Our developer bot WorkerB provides the context that developers need to start a review: related issue and estimated review time. It can even detect when a pull request isn’t linked to a Jira ticket and help you create one in a single click, all in an automated notification. 

![workerb](https://assets.linearb.io/uploads/WorkerB-Landing-Page.png)

## Keep the Code Changes Small

There are two general rules of thumb around code reviews: the 60 Minute Rule and the 400 Lines Rule. 

The 60 Minute Rule says [do not review code for longer than 60 minutes in a single sitting](https://smartbear.com/learn/code-review/best-practices-for-peer-code-review/). Attention to detail and performance level drop after that point. So, conduct code reviews in short sessions. 

The 400 Lines Rule recommends you [never check more than 400 lines of code in a single review session](https://smartbear.com/learn/code-review/best-practices-for-peer-code-review/). This will ensure that you review the code with maximum efficiency and concentration. 

Our data science team at LinearB studied nearly 2,000 dev teams and discovered that elite engineering teams keep their [average code reviews to under 225 changes](https://linearb.io/engineering-benchmarks). 

## Give Constructive Feedback

Give constructive rather than critical feedback. Advise your team to ask questions and avoid making statements. Praising good efforts by your team members will help encourage this behavior as well. 

You must foster a positive review culture. So, it should not matter who initiated the error. What matters is that you caught the bug before it affected your product. 

Encourage your team to collaborate on peer reviews via Zoom or MS Teams if there are significant changes. It’s a more effective means to communicate feedback because you can hear the person’s positive tone that you might miss in an [async communication method](https://linearb.io/blog/asynchronous-communication-future). 

Plus, genuine feedback results in developer growth and deeper reviews.

## Include All Team Members in Your Code Review Process

Make sure everyone on your team is given the opportunity to review code. Include both engineers as well as software architects. The collaboration and back-and-forth feedback exchange between junior developers and experienced developers can raise the overall awareness and experience of your entire team.

## Automate to Improve

In a challenging new world where engineering teams work remotely (at times thousands of miles away),[ code review automation tools](https://linearb.io/blog/automated-code-review) are becoming the new normal. These code review tools save time, eliminate manual tasks, reduce context switching, and project idle time through personal automation for developers. 

Our developer bot WorkerB was designed with these objectives in mind. As you make changes to your code review process, you can actually set goals in LinearB and then automated WorkerB notifications warn your team when these goals aren’t met.

For example, I noted earlier that code quality issues are often related to code being merged without a review at all or being merged with superficial feedback. You can set goals to ensure that no code is merged without review again, and WorkerB will notify the team when this occurs. Your team can then take action to revert it and review it before it goes to production. 

[![Identify your team rebels. Schedule a demo of WorkerB alerts for PRs merged without review.](https://assets.linearb.io/uploads/Merged-Without-Review-1024x497.png)](https://linearb.io/get-started)

Improve your code review process with alerts for PRs merged without review. [Get started with our free-forever account today!](https://linearb.io/get-started)

## Measure & Iterate on Your Code Review Process

The last step in improving your code review process is measuring the improvements and impact with team-based metrics. 

Since one of the main issues a better code review process can solve is high cycle time, a great metric to start tracking for improvement is[ cycle time.](https://linearb.io/blog/cycle-time) But additionally, if the code quality improves in the process, your code churn or rework ratio should decrease.

For this, you can use the LinearB Metrics Dashboard. It provides a birds-eye view of the information you need to see if your process changes are improving your team performance and software development lifecycle.

![Quality Metrics](https://assets.linearb.io/uploads/metrics-slides-quality-1024x658.webp)

## **Best Practices and the Right Tools: A Perfect Combination**

When performed correctly, the code review process improves nearly every aspect of your team. Imagine what less rework and a shorter cycle time could mean for your sprint planning accuracy. You might actually be able to deliver on your promises and ship features faster! 

[![Improve PR Process Teams that improve their PR process especially PR size with LinearB see: Less code churn, Higher code quality, Less idle time & toil, and Reduced context switching](https://assets.linearb.io/uploads/improve-pr-process-recipe-1024x575.png)](https://linearb.io/pr-process)

We know that streamlining your PR process impacts your productivity and efficiency. Learn more about [our five-step recipe for improvement](https://linearb.io/pr-process).

## Improve developer productivity with LinearB

Find us on

[](https://www.linkedin.com/company/linearb)
[](https://devinterrupted.substack.com/)

## Your next read

[![Cover image for Slack turns channels into the context engine for agentic AI](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_077524ba8b?_a=BAVMn6ID0)](https://linearb.io/blog/slack-jaime-delanghe-mcp-agent-context-channels)

Workflow

[Slack turns channels into the context engine for agentic AI](https://linearb.io/blog/slack-jaime-delanghe-mcp-agent-context-channels)

Slack Chief Product Officer Jaime DeLanghe breaks down how channels serve as the foundational context layer for human-agent collaboration. Learn why Slack is...

[![Cover image for Code generation is faster than ever, but shipping value isn't](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_AI_code_review_bottleneck_2400x1256_d73333ea46?_a=BAVMn6ID0)](https://linearb.io/blog/code-generation-faster-shipping-isnt)

Workflow

[Code generation is faster than ever, but shipping value isn't](https://linearb.io/blog/code-generation-faster-shipping-isnt)

Your team writes more code than ever, but less reaches production. AI moved the bottleneck to code review. Here's how to measure it and unblock your pipeline.&n...

[![Cover image for AI as a value multiplier: a human-centric approach to engineering leadership](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Servant_Leadership_2400x1256_0cfd4e2a0c?_a=BAVMn6ID0)](https://linearb.io/blog/ai-as-value-multiplier-human-centric-leadership)

Workflow

[AI as a value multiplier: a human-centric approach to engineering leadership](https://linearb.io/blog/ai-as-value-multiplier-human-centric-leadership)

Super.com's Matt Culver explains why AI should be used as a value multiplier, not a cost-cutter, advocating for a human-centric approach to engineering...

## Structured data

_Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._

```json
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "LinearB",
  "url": "https://linearb.io/",
  "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg",
  "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.",
  "sameAs": [
    "https://www.linkedin.com/company/linearb"
  ],
  "award": [
    {
      "@type": "Award",
      "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms",
      "dateAwarded": "2026",
      "awardedBy": {
        "@type": "Organization",
        "name": "Gartner®"
      }
    },
    {
      "@type": "Award",
      "name": "Great Place to Work Certification",
      "dateAwarded": "2025-2027",
      "awardedBy": {
        "@type": "Organization",
        "name": "Great Place to Work"
      }
    },
    {
      "@type": "Award",
      "name": "America's Best Startup Employers 2025",
      "dateAwarded": "2025",
      "awardedBy": {
        "@type": "Organization",
        "name": "Forbes Magazine"
      }
    }
  ],
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "SOC 1 Type 2"
    },
    {
      "@type": "Certification",
      "name": "SOC 2 Type 2"
    },
    {
      "@type": "Certification",
      "name": "GDPR Compliance certification"
    },
    {
      "@type": "Certification",
      "name": "ISO 27001"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How to Do Code Reviews Better",
  "url": "https://linearb.io/blog/how-to-do-code-reviews-better",
  "author": {
    "@type": "Person",
    "name": "Brandi M."
  },
  "datePublished": "2022-03-17T17:57:57.000Z",
  "dateModified": "2022-03-17T17:57:57.000Z",
  "image": "https://assets.linearb.io/image/upload/v1720000000/How_to_do_a_code_review_1a24e93efa.jpg",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "Code reviews have become a vital part of the software development process. They improve code quality, developer performance, and save development teams time. But only when done correctly. So what does a good code review look like? Why is it so important? And can any part of the process be automated? To answer these questions, […]\n"
}
```

## More on linearb.io

### Top navigation

- [Book a Demo](https://linearb.io/book-a-demo)
- [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews)
- [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights)
- [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact)
- [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server)
- [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation)
- [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization)
- [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting)
- [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance)
- [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support)
- [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience)
- [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience)
- [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys)
- [Platform overview](https://linearb.io/platform/overview)
- [Register now](https://linearb.io/event/engineering-productivity-gap)
- [Customers](https://linearb.io/customers)
- [Pricing](https://linearb.io/pricing)
- [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb)
- [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework)
- [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq)
- [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security)
- [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy)
- [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts)
- [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources)
- [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops)
- [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report)
- [Blog — Product updates and practical insights](https://linearb.io/blog)
- [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io)
- [API Docs](https://docs.linearb.io/api-overview)
- [Status](https://www.linearbstatus.com/)
- [Integrations](https://linearb.io/integrations)
- [LinearB Library](https://linearb.io/library)
- [Engineering metrics](https://linearb.io/library/engineering-metrics)
- [Platform engineering](https://linearb.io/library/platform-engineering)
- [Engineering glossary](https://linearb.io/library/engineering-glossary)
- [Developer productivity](https://linearb.io/library/developer-productivity)
- [AI in software development](https://linearb.io/library/ai-in-software-development)
- [Engineering management](https://linearb.io/library/engineering-management)
- [Developer experience](https://linearb.io/library/developer-experience)
- [DevOps](https://linearb.io/library/devops)
- [Engineering operations and the context layer](https://linearb.io/library/engineering-operations)
- [Engineering efficiency](https://linearb.io/library/engineering-efficiency)
- [Software delivery](https://linearb.io/library/software-delivery)
- [Research and data](https://linearb.io/library/engineering-benchmarks-and-research)
- [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026)
- [Sign in](https://app.linearb.io/login)
- [Enterprise](https://linearb.io/solutions/enterprise)
- [Contact](https://linearb.io/contact-us)
- [About us](https://linearb.io/about-us)
- [Careers](https://linearb.io/careers)
- [Service agreement](https://linearb.io/services-agreement)
- [Privacy policy](https://linearb.io/privacy-policy)
- [DPA](https://linearb.io/data-processing-agreement)
- [Security FAQ](https://linearb.io/security-faq)
- [Substack](https://devinterrupted.substack.com/)

### Footer

_Additional links from the site footer, not repeated from the top navigation above._

- [GitHub](https://github.com/linear-b)
- [LinkedIn](https://www.linkedin.com/company/linearb)
- [Twitter](https://twitter.com/LinearB_Inc)