# Why Estimated Review Time Improves Pull Requests And Reduces Cycle Time | LinearB Blog

> The smallest thing you can do to make the biggest impact on cycle time? Add estimated time to review to pull requests.

_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": "Why Estimated Review Time Improves Pull Requests And Reduces Cycle Time",
      "item": "https://linearb.io/blog/why-estimated-review-time-improves-pull-requests-and-reduces-cycle-time"
    }
  ]
}
```

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

/

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

/

Why Estimated Review Time Improves Pull Requests And Reduces Cycle Time

# Why Estimated Review Time Improves Pull Requests And Reduces Cycle Time

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

By [gitStream Team](https://linearb.io/blog/why-estimated-review-time-improves-pull-requests-and-reduces-cycle-time#git-stream-team)

|

November 18, 2022

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

### **TL;DR**

* The pull-request review process is a pain. Data shows this is a major bottleneck.
* Pull-request review speed & quality can be improved by adding context to pull requests, like [estimated time to review](#AddETR)
* Review automation tools like [gitStream](https://github.com/marketplace/gitstream-by-linearb) can add context for reviewer

## Data shows an insane bottleneck in code reviews

The code review and pull-request process continues to be a major bottleneck for developers and dev teams. In a recent study, LinearB inspected \~1,000,000 PRs and found the following that: Pull requests are waiting on average 4+ days before being picked up.

Studies show pull requests & code review pickups are the no. 1 bottleneck in cycle time

Although there have been significant gains in coding times and deployment times; the amount of time it takes to start a pull-request review and the amount of time it takes to complete a pull-request review continue to disappoint. 

The good news? There are things we can all do to break this bottleneck.

## **Context that allows developers to easily pick up pull requests is a game-changer**

One key – and there are many keys – to improving both pull-request review speed and quality is providing as much up-front context to the reviewer as possible.

#### **Examples of context proven to improve pickup time:**

* Estimated Review Time
* Labeling low–risk changes like Documentation or Test changes only
* Labeling high-risk changes like Core services, API Database or, Security
* Ticket or Issue links
* Test-coverage impact

### **What happens when estimated time of review (ETR) is added to pull requests?**

Plain and simple: When a pull requests is labeled with how long it will take to review it – be it 5 minutes or 60 mixtures – developers:

1. Are more likely to pick up pull requests quickly
2. Are more likely to have have their reviews completed quickly

The longer a developer assumes a code review will take, the longer they will take to respond to it.

**Why do pull requests with ETR get picked up faster and reviewed quickly?**

Developers are knowledge workers, not cogs in a machine. By simply adding estimated time to review, you accommodate cognitive biases we all have. Specifically, 

* Knowing the review time allows the reviewer to schedule the best time to start the review. The key is to find a time that allows for non-interruption.
* Cognitive reload occurs when a PR review is started and then not completed typically due to interruption. This causes a cognitive reload for the reviewer, starting the review over close to the beginning and extending the review time.
* Conversely, the review can be rushed at the expense of quality. Fitting a 30 minute review into a 15 minute window results in quality gaps.

## Two ways to add ETR to your pull requests

1. Create a template standard like [this](https://www.gitkraken.com/blog/enhancing-pull-request-descriptions-templates); or
2. Use PR Review Automation like , see below

To get started you need to install on your repository from GitHub marketplace. <https://docs.gitstream.cm/github-installation/> and add 2 workflow files to your repo:

1. [gitstream.cm](https://docs.gitstream.cm/github-installation/);
2. [github action file](https://docs.gitstream.cm/github-installation/).

The default “gitstream.cm” file has estimated time to review already setup for you, but let’s dig into it a bit to see what it’s actually doing:

```
automations:
  estimated_time_to_review:
    if:
      - true
    run:
      - action : add-label@v1
        args:
          label: "{{ branch | estimatedReviewTime }} min review"
```

Let’s look at this snippet of yaml in the gitstream.cm file. [“automations](https://docs.gitstream.cm/editing-cm-file/#automations)” keyword sets up the listing where all your automations will live and you can have an unlimited number of them. The next line is where you name your automation, in this case it’s “estimated\_time\_to\_review,” which will add an estimated time to review label on every PR run through gitStream. 

Next is our conditional, in this case we just need it to be true, but you can use regular expressions, line counts and a lot more [here](https://docs.gitstream.cm/editing-cm-file/#automations) to check the code in the pr and then act on it. 

After the conditional, we need to run some actions from the conditions being met. 

In this case, we run the add-label@v1 action which will add the label to the PR based on the arguments we give it. In the arguments (args) we provide a string that adds in the estimated time to review as the label to the PR.

**How does gitStream determine ETR?**

The estimated review time is predicted using a machine-learning model developed in LinearB and trained on millions of PRs. It incorporates features including:

* The size of the PR, including details of additions, deletions, etc.
* The file types that were modified, and the extent of the changes on these files
* The codebase (repository) involved, and the familiarity of the PR issues with the code base

The review time prediction is then bucketed into a useful time range (e.g. 15-30 minutes) to provide the final estimate

Now that we have our estimated time to review, let’s mark what type of PR this can be. Let’s do this by adding some color to the labels.

We can also apply color coded labels providing a visual cue to help reviewers, let’s also add some code to hold state for the estimated time to review so it updates. The code below adds this functionality. By adding the “calc” we can get the updated estimatedReviewTime as it is updated per this branch.

```
automations:
  estimated_time_to_review:
    if:
      - true
    run:
      - action: add-label@v1
        args:
          label: "{{ calc.etr }} min review"
          color: {{ 'E94637' if (calc.etr >= 20) else ('FBBD10' if (calc.etr >= 5) else '36A853') }}

# To simplify the automation, this calculation is placed under a unique YAML key.
# The result is assigned to `calc.etr` which is used in the automation above.
# You can add as many keys as you like.

calc:
  etr: {{ branch | estimatedReviewTime }}
```

Now you know how to add context to your PRs with gitStream, this article just scratches the surface of what is possible, please check out the [gitStream docs](https://docs.gitstream.cm) to learn more.

In future posts we’ll dive into using [gitStream ](https://gitstream.cm)to do code review automation and having gitStream help find the right reviewers for your PR with reviewer automation.

## 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": "Why Estimated Review Time Improves Pull Requests And Reduces Cycle Time",
  "url": "https://linearb.io/blog/why-estimated-review-time-improves-pull-requests-and-reduces-cycle-time",
  "author": {
    "@type": "Person",
    "name": "gitStream Team"
  },
  "datePublished": "2022-11-18T17:43:05.000Z",
  "dateModified": "2022-11-18T17:43:05.000Z",
  "image": "https://assets.linearb.io/image/upload/v1720000000/automated_code_review_tools_1_30dbb79e24.png",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "The smallest thing you can do to make the biggest impact on cycle time? Add estimated time to review to pull requests.\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)
- [Watch 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)