# Cycle Time Breakdown: Tactics For Reducing PR Review Time | LinearB Blog > This is the third installment of our Cycle Time Breakdown series on the most effective tactics to speed up your development Cycle Time. The other posts are: Table of Contents The Issue Before a delta can be merged into the source code, it needs to be reviewed to find defects and to ensure that it […] _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)._ [Blog](https://linearb.io/blog) / Cycle Time Breakdown: Tactics For Reducing PR Review Time # Cycle Time Breakdown: Tactics For Reducing PR Review Time ![Photo of Nick Hodges](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/logo-mark-lg?_a=BAVMn6ID0) By [Nick Hodges](https://linearb.io/blog/reducing-pr-review-time#nick-hodges) | August 4, 2021 ![Review_Time_Featured_Image_efc6d40e7a](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Review_Time_Featured_Image_efc6d40e7a?_a=BAVMn6ID0) This is the third installment of our Cycle Time Breakdown series on the most effective tactics to speed up your development Cycle Time. The other posts are: * [Tactics For Reducing Coding Time](https://linearb.io/blog/reducing-coding-time/) * [Tactics For Reducing Pull Request Pickup Time](https://linearb.io/blog/pull-request-pickup-time/) * Tactics For Reducing PR Review Time ← You are here * [Tactics For Reducing Deploy Time](https://linearb.io/blog/cycle-time-breakdown-tactics-for-reducing-deploy-time/) ## Table of Contents * [The Issue](#issue) * [What’s A Good Review Time?](#good) * [Causes of High Review Time (And How You Can Address Them)](#causes) * [The End Result](#result) ## The Issue Before a delta can be merged into the source code, it needs to be reviewed to find defects and to ensure that it conforms to a team’s general principles for style and organization. In practice, reviewing code can often end up being a bottleneck. A developer will start a review, then get pulled into another task. They can end up forgetting about the review all together. This means that instead of new code being deployed and improving the application, it just sits there, doing nothing. Review Time is one of the four components of Cycle Time. When teams start using LinearB, they are often surprised to see just how long reviews are taking. ![cycle time benchmarks](https://assets.linearb.io/uploads/cycle-time-benchmarks-1024x819.png) ## What’s A Good Review Time? We got this question a lot from our customers. So we went out and got the answer. We analyzed data from almost 2,000 teams and over 847,000 branches to establish [benchmarks for key engineering metrics](https://linearb.io/engineering-benchmarks/), including Review Time. You can see the results in the table below. ![Engineering benchmarks chart](https://assets.linearb.io/uploads/benchmarks-chart-1024x670.png) Want to learn more about being an elite engineering team? [Check out this blog](https://linearb.io/blog/engineering-metrics-benchmarks-what-makes-elite-teams/) detailing our engineering benchmarks study and methodology. Elite teams typically take less than 6 hours for PR code reviews; strong teams take up to 13\. **A good rule of thumb is to keep your review times to less than 12 hours**. If a PR is created in the morning, it should be reviewed by the end of the day. If it’s created in the evening, it should be reviewed the following morning. ## Causes of High Review Time (And How You Can Address Them) There are four main causes of high review times: 1. The pull request is too big 2. The team has too much Work in Progress (WIP) 3. The team gets diverted into other work 4. Too few people are assigned to do reviews 5. The review has been forgotten about ### Pull Request Is Too Big As we talked about in the post about [pull request pickup time](https://linearb.io/blog/pull-request-pickup-time/), people are reluctant to review big PRs, and with good reason. A big PR means that there are going to be lots of code changes to go through. Not only that, but a big PR usually signals that the reviewer is going to have to parse multiple kinds of changes. For example, instead of just making sure the author updated the design of one button in all the right places, they have to check that and whether the author also properly handled errors in a new authentication flow and improved logging and properly added tests cases and…Keeping track of all these different kinds of changes makes it [harder to conduct effective code reviews](https://linearb.io/blog/code-review-best-practices/#limit-pr-size). Here’s the mantra to keep in mind: **Commit small, commit often**. The more precisely you scope a PR, the easier it is to review and the faster it can get into production. Based on our analysis, the best teams keep PR sizes below 225 lines of code, and strong teams less than 400 lines. LinearB can help your team drive down the size of your PRs. You can track PR size in a custom dashboard and you can set up WorkerB alerts so that you know when a big PR has been created. [![Nobody wants to review your huge pull request.](https://assets.linearb.io/uploads/pr-size-get-started-1024x497.png)](https://linearb.io/get-started/) Improve your code quality and developer workflow with smaller pull requests. [Get started with your free-forever LinearB account today.](https://linearb.io/get-started/) ### Too much WIP Reviews are often de-prioritized in favor of other work, like creating your own pull requests that have changes that you’ve made. This is because engineers are misunderstanding how reviews fit into the broader software development lifecycle (SDLC). Code that needs a review is at the finish line, waiting to be allowed across and to start adding value. **Every hour a review is put off, is an hour less that a new chunk of code has to improve the application.** In addition to resetting your team’s understanding of PR reviews, as a team lead you should also make sure that your developers have the bandwidth for reviews. Otherwise, your efforts to get them to conduct reviews more quickly may lead to resentment because it’ll feel like you’re just asking them to do more work. You can help them to meet your expectations by introducing a standard [code review checklist](https://linearb.io/blog/code-review-checklist/). You can also leverage LinearB. With LinearB’s People metrics, you can see where your team members are spending time so that you redistribute work or help individuals better allocate their time. Burnout is a serious concern among fast-moving development teams, which is why we built out functionality to alert you if a member of your team has maybe taken on too much work. ![team health](https://assets.linearb.io/uploads/Group-1308_2x-1024x490.png) ### Diverted into other work A bug is discovered, and a patch needs to be made. A high-priority feature request comes down from the CEO. There are million and one things that can arise out of the blue and demand immediate attention from your team. When this happens, all other work, including any reviews they may have been working on, get put on the back burner. ### Too few people are assigned to do reviews To maintain high quality code, PR reviews are an indispensable tool. But this pursuit of quality can sometimes go too far. Some teams limit the number of people who can review PRs, usually the more senior members of the team. This is well-intentioned. It ensures that only high quality code gets pushed into production. It also helps reviews serve as [learning tools](https://linearb.io/blog/what-is-code-review-why-its-important-for-code-quality/). But it can result massive bottlenecks, with review requests piling up on just one or a few people. You improve code quality, but this comes at the expensive of much slower cycle times. On the Dev Interrupted podcast, Maria Gutierrez, VP of Engineering at Slack, explained how she learned the importance of “diversifying responsibility” in engineering orgs. By making it easier for the rest of her teams to review and deploy code, she transformed how they worked. There’s a reason many teams call PR reviews “[peer code reviews](https://linearb.io/blog/what-is-code-review-why-its-important-for-code-quality/#code-reviews-make-you-more-resilient).” When peers review one another’s code, you help everyone broaden their knowledge of the code base, empowering them to work on more areas and making your application more resilient. ### The review has been forgotten about It happens…a lot. A developer starts a review, then has to jump to another task, and forgets to come back to the review until either they randomly remember or more likely the PR submitter pings them. Days and weeks can fly by as a review is still “in progress.” This is a serious problem but an avoidable one. LinearB’s WorkerB automation bot can send out alerts to let people know that a review has been sitting idle. This ensures that the review gets completed, greatly reducing code review time, and it saves time for the other members of the team because they don’t have to do the reminding. Promote your pull requests to merge 10x faster. [Get started with our free-forever account today!](https://linearb.io/get-started/) ## The End Result The PR Review stage is a bottleneck for lots of engineering teams, but it doesn’t have to be. By ensuring that your team understands the value of prompt reviews, distributing responsibility, and leveraging a tool like LinearB, you can improve your code review process, drive down your teview times, and speed up your cycle time. One of our customers, Unbabel, an artificial intelligence-powered human translation platform, [saw a 40% decrease in review time](https://linearb.io/blog/customer-story-unbabel/) when following these principles while using LinearB. --- Want to learn how to implement custom dev workflow automation to cut code review time by up to 40%? [Watch this hands-on workshop](https://linearb.io/event/202303-gitstream-workshop/) to set up the free gitStream tool to automatically: ![:white_check_mark:](https://a.slack-edge.com/production-standard-emoji-assets/14.0/apple-medium/2705.png) Classify and route pull requests Add estimated review time to PRs Apply custom rules ![gitStream Workshop: Getting started with workflow automation](https://assets.linearb.io/uploads/LinearB-Youtube-Card_-Ofer-Guy-Gitstream-Workshop_-Getting-Started-With-Workflow-Automation-2-1024x576.png) gitStream product lead, Ofer Afias, will take you through a live demo of the three core functions when getting started with gitStream workflow automation to scale your team efficiently and improve your developer experience. --- ## 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": "Cycle Time Breakdown: Tactics For Reducing PR Review Time", "url": "https://linearb.io/blog/reducing-pr-review-time", "author": { "@type": "Person", "name": "Nick Hodges" }, "datePublished": "2021-08-04T09:56:25.000Z", "dateModified": "2021-08-04T09:56:25.000Z", "image": "https://assets.linearb.io/image/upload/v1720000000/Review_Time_Featured_Image_efc6d40e7a.png", "publisher": { "@type": "Organization", "name": "LinearB", "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png" }, "description": "This is the third installment of our Cycle Time Breakdown series on the most effective tactics to speed up your development Cycle Time. The other posts are: Table of Contents The Issue Before a delta can be merged into the source code, it needs to be reviewed to find defects and to ensure that it […]\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 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)