# Continuous Merge Guide to Merge Standards | LinearB Blog

> To take the first step towards Continuous Merge, engineering leaders should implement a set of merge standards on their teams to establish policy-as-code and ensure consistent adoption across the organization. 

_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": "Continuous Merge Guide to Merge Standards",
      "item": "https://linearb.io/blog/continuous-merge-guide-to-merge-standards"
    }
  ]
}
```

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

/

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

/

Continuous Merge Guide to Merge Standards

# Continuous Merge Guide to Merge Standards

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

By [Natalie Breuer](https://linearb.io/blog/continuous-merge-guide-to-merge-standards#natalie-breuer)

|

November 13, 2023

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

## **The State of CI/CD**

The 1990’s marked a distinct and challenging era in software development, characterized by late night pipeline stabilization sessions, weeks-long code freezes, projects spanning six months, and even lengthier customer feedback loops.

Then, in 2001 the Agile Manifesto was published, and slowly began revolutionizing software development as we knew it. As agile methodologies gained traction in the industry, customer expectations continued to rise, and engineering teams that adopted scrum over the traditional waterfall approach were suddenly developing features at a faster pace than their operations counterparts could match. 

As with any great paradigm shift, this discrepancy in speed highlighted a new challenge: the need to build a faster delivery pipeline. 

![Frame 6774 (3).jpg](https://assets.linearb.io/image/upload/v1720000000/Frame_6774_3_b728b65470.jpg)

In response to this demand for accelerated delivery, CI/CD automation and the DevOps movement emerged in the early 2010s. 

CI/CD automation opened up possibilities for new architectural approaches like microservices, integrated security, and GitOps – all with the ultimate goal of transforming the way software is built and delivered.

These advances all promised the same things: 

1. More time to code for developers
2. Reduced uncertainty and bugs detected earlier
3. A faster, more reliable delivery pipeline & customer feedback loop

Unfortunately, the “more time to code” part didn’t fully pan out, as evidenced by a recent [Clockwise study](https://www.getclockwise.com/eng-meeting-benchmarks) that concluded developers only have 20 hours of focus time per week. And as such, today we find ourselves on the brink of yet another evolution in software development.

![Image (6).jpg](https://assets.linearb.io/image/upload/v1720000000/Image_6_454fc61a1e.jpg)

#### Want this guide sent directly to your inbox? [**Click here and enter your email!**](https://linearb.io/resources/continuous-merge-white-paper)

## **Where CI/CD Can Be Improved** 

While the benefits of CI/CD – including faster time to market, higher code quality, better collaboration, and reduced risk – can’t be denied, the widespread adoption of CI/CD practices has given rise to a new set of issues: the most glaring of all being the Merge Frequency Problem.

At LinearB, our data analysis team has spent the past 3 years researching cycle time, or the time between when coding begins to when a pull request (PR) is deployed. After analyzing millions of PRs from thousands of dev teams across organizations of all sizes, we found that the average cycle time is 7 days.

But what's really interesting is that most PRs lay stagnant in the review process for 5 of those 7 days. Even worse, we found that the majority of those 5 days resulted in an “LGTM” type review. Painful, we know.

Ultimately, our research revealed two truths: 

1. The PR review cycle is the main bottleneck engineering teams have to overcome.
2. If the code someone wrote, assuming it was properly tested, is released soon after it’s written, there is a better chance of catching a bug while the code & context is still fresh in the developer’s head.

Pull request reviews that take days or weeks have significant cost implications. Besides work backlogs, delayed reviews can trigger complex merge conflicts. Even worse, pull requests come before integrated testing in the CI/CD pipeline, so a successful review doesn’t guarantee a similar outcome later. 

And so yesterday’s solutions have exposed the next big challenge for today’s developers: actually getting code merged.

## **What is Continuous Merge?** 

[Continuous Merge](https://linearb.io/blog/what-is-continuous-merge) is a guiding practice behind how engineering organizations program their delivery pipeline. Simply put, it’s a way of applying workflows that optimize the PR merge path for both velocity and quality.

![CI (2).jpg](https://assets.linearb.io/image/upload/v1720000000/CI_2_a8834f3cf1.jpg)

To get started with automated workflows, technical leads can create a simple .cm file that programmatically defines the rules and automation for how their team’s PR process is managed. These rules can help engineering teams: 

* Check for the use of deprecated APIs and services
* Automatically identify and assign an expert reviewer
* Unblock low-risk improvements
* Indicate estimated review times, and much more

Repo-based review automations will allow you to eliminate standard, or one-size-fits-all PR review processes, in lieu of routing PRs based on custom criteria.

## **Why Should I Care About Continuous Merge?** 

Continuous Merge isn’t just a category, it’s a mindset. And teams that adopt its philosophy and introduce pre-merge workflow automation into their processes will benefit from the following downstream effects: 

1. **Increased Efficiency:** Continuous Merge streamlines the release process, allowing businesses to automatically approve safe changes, assign the best reviewer, and request changes when PRs don’t meet your expected best practices. What’s more, implementing automation into the SDLC enables developers to focus on what they really love – coding – instead of spending their time on manual review and merge tasks.
2. **Enhanced Quality:** Continuous Merge facilitates more thorough reviews, leading to higher quality code, adherence to compliance best practices, and fewer bugs. Additionally, automation that alerts developers to high-risk changes, PRs where an expert reviewer is needed and missing data objects can help them identify and address problems early, ensuring higher stability over time.
3. **Continuous Improvement:** Continuous Merge promotes a culture of continuous improvement and learning. Standardizing merge processes can drive best practices across your organization. And workflow automation can help you expand codebase knowledge between teams and fasttrack ramp time for new hires.
1. **Business Agility:** The ability to merge code faster and at a higher quality enables your organization to gain a competitive advantage. Continuous Merge allows business to respond quickly to market demands, competitive pressures, and ever changing customer needs. It fosters agility and flexibility in software development, enabling your team to adapt, innovate, and deliver value faster.

![Image (7).jpg](https://assets.linearb.io/image/upload/v1720000000/Image_7_dafa09eea8.jpg)

Want this guide sent directly to your inbox? 

### **The First Step Towards Continuous Merge** 

Most engineering organizations do not have the visibility or mechanisms in place to enforce or audit merge policy across multiple dev teams. And this inconsistency can give rise to poor collaboration, onboarding, context switching, and a lack of code quality.

To take the first step towards Continuous Merge, engineering leaders should start by implementing a set of merge standards on their team that will then be adopted as policy at the organizational level. 

Adhering to merge standards establishes best practices for shipping code to maintain quality, facilitate collaboration, and boost efficiency.

![Frame 6777.jpg](https://assets.linearb.io/image/upload/v1720000000/Frame_6777_8153539122.jpg)

Merge standards dictate the decision for “if” “then” scenarios. When practicing Continuous Merge, your merge standards should balance velocity with quality. 

Before we dive in, it’s important to note that merge standards can vary widely org to org (and even team to team), depending on factors like company size and maturity. We suggest using the following merge standards as a jumping off point then customizing them to your team's processes as you see fit. From there, you can align at a higher level and reap the benefits of Continuous Merge. 

At LinearB, we think of merge standards in two separate categories: 

1. Merge standards that enforce quality
2. Merge standards that boost efficiency

First and foremost, code quality plays a vital role in reliability and collaboration. When code is well-structured and properly documented, it becomes easier for developers to review and merge – either individually or as a team. What’s more, high-quality code is easier to scale as software evolves, allowing for easier integration of new features moving forward. 

![Frame 6777 (1).jpg](https://assets.linearb.io/image/upload/v1720000000/Frame_6777_1_e9ffc7436c.jpg)

With that said, code quality is only one side of the equation. Top-performing engineering organizations must also optimize for speed.

## **Applying Merge Standards with Policy-as-Code** 

Engineering teams have two options when it comes to implementing merge standards: they can do so manually or they can leverage workflow automation.

The first option, albeit time consuming and task oriented, is certainly do-able. 

To start, we recommend working with your team to evaluate your existing code merge practices. It can be helpful to ask questions like: 

* Which practices help us ensure high code quality?
* When we collaborate well, what tend to be the reasons?
* What processes enable devs to get code out the door quicker?

Now that you’ve aligned with your team on what’s most important to standardize, it’s time to create a comprehensive document outlining your team’s new merge standards. Feel free to pull from our team’s guide (above) or create your own from scratch.

From there, publish your merge standards somewhere easily accessible, like on your team’s wiki, then conduct a training session to talk through best practices and address any questions or concerns. It can also be helpful to record this session for future hires to review during the onboarding process.

Moving forward, because these standards are subject – and even likely – to change, we recommend evaluating and updating your merge standards at least once a year.

Alternatively, engineering teams have the option to adopt workflow automation. To take the first steps towards Continuous Merge, we recommend [installing gitStream](https://linearb.io/platform/gitstream), a free workflow automation tool that applies policy rules to your repos that classify and route your PRs.

With [gitStream](https://linearb.io/platform/gitstream), engineering teams can customize their code review workflows for each pull request, based on the content of the code. 

Continuous Merge using gitStream starts with a simple .cm file that programmatically defines how your PR process is managed. 

From there, users can implement a set of rules that will help instill a culture of quality and efficiency on their teams like: 

![CI (3).jpg](https://assets.linearb.io/image/upload/v1720000000/CI_3_61a56361c1.jpg)

#### Want this guide sent directly to your inbox? 

## **The Future of Continuous Merge**

Teams that build a culture of Continuous Merge save developer time, reduce headaches, and become more productive. 

The key is removing friction (toil and idle time) from the dev process by creating programmable workflows that classify and route PRs based on their contents. 

![Image (8).jpg](https://assets.linearb.io/image/upload/v1720000000/Image_8_f63759905f.jpg)

 marks a shift in the way developers will automate their workflows for years to come. It’s time to wave goodbye to a one-size-fits-all approach to code reviews, and welcome a new era of scalable policy-as-code. 

With standardization and repeatability built into your development workflows, growing teams can move faster and scale efficiently. 

Setting up gitStream takes less than 3 minutes. [Set up your first rule today. ](https://linearb.io/platform/gitstream)

To learn more about Continuous Merge and how it can be leveraged to optimize every leg of your SDLC, check out our other CM Guide: 

* [Continuous Merge Guide to Code Quality](https://linearb.io/resources/continuous-merge-guide-to-code-quality)

## Improve developer productivity with LinearB

Find us on

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

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

## Natalie Breuer

Natalie Breuer, now a Senior Product Marketing Manager at LinearB, has been in the Developer Productivity Insights space since 2019\. A writer at heart, Natalie loves bringing technical topics to life with human stories – bridging the gap between data and storytelling.

## Your next read

[![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)

Leadership

[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...

[![Cover image for The Moneyball approach to engineering leadership](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Balancing_Technical_Depth_2400x1256_b56d93a733?_a=BAVMn6ID0)](https://linearb.io/blog/moneyball-approach-engineering-leadership)

Leadership

[The Moneyball approach to engineering leadership](https://linearb.io/blog/moneyball-approach-engineering-leadership)

Rethink engineering leadership with Transcend's Minh Nguyen and learn how to balance hands-on technical work with strategic leadership, communicate with a...

[![Cover image for Strategic lessons from Google on improving engineering teams](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Strategic_Lessons_From_Google_2400x1256_1_cd28b7242d?_a=BAVMn6ID0)](https://linearb.io/blog/strategic-lessons-google-engineering-teams)

Leadership

[Strategic lessons from Google on improving engineering teams](https://linearb.io/blog/strategic-lessons-google-engineering-teams)

Learn key lessons from Google on aligning engineering with business goals, boosting developer productivity, and building sustainable team culture.

## 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": "Continuous Merge Guide to Merge Standards",
  "url": "https://linearb.io/blog/continuous-merge-guide-to-merge-standards",
  "author": {
    "@type": "Person",
    "name": "Natalie Breuer"
  },
  "datePublished": "2023-11-13T14:08:11.204Z",
  "dateModified": "2023-11-13T14:08:11.204Z",
  "image": "https://assets.linearb.io/image/upload/v1720000000/best_programming_languages_7aa09e9d1a.jpg",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "To take the first step towards Continuous Merge, engineering leaders should implement a set of merge standards on their teams to establish policy-as-code and ensure consistent adoption across the organization. "
}
```

## 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)