# Can no-mistakes be integrated into CI/CD pipelines? Complete Implementation Guide

> Integrate no-mistakes into your CI/CD pipelines with our complete guide. Learn how to leverage its CI-monitoring for automated fixes and ensure smoother deployments. Get started today.

- Repository: [Kun Chen/no-mistakes](https://github.com/kunchenguid/no-mistakes)
- Tags: how-to-guide
- Published: 2026-07-11

---

**Yes, no-mistakes can be integrated into CI/CD pipelines through its built-in CI-monitoring step that polls provider APIs, reports status, and auto-fixes failures.**

The `no-mistakes` repository (kunchenguid/no-mistakes) includes a native CI/CD integration capability that allows it to monitor, report, and automatically resolve continuous integration failures. This functionality enables development teams to enforce code quality gates within existing pipeline workflows without requiring external orchestration tools.

## How the CI Pipeline Integration Works

The integration centers on the `CIStep` implementation located in [`internal/pipeline/steps/ci.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/pipeline/steps/ci.go). When you execute `no-mistakes run`, the pipeline automatically instantiates this step to monitor pull request status.

### Provider Detection and API Communication

The step begins by detecting your source control provider through `scm.DetectProvider`, which analyzes the repository URL to identify GitHub, GitLab, or Bitbucket. It then instantiates provider-specific clients from `internal/scm/github`, `internal/scm/gitlab`, or the corresponding Bitbucket packages to query PR state, mergeability, and CI check results via native APIs.

### Polling and Status Interpretation

The implementation polls the pull request at configurable intervals, re-arming an idle timeout whenever the upstream default branch advances (managed through `defaultBaseBranchTipResolveWindow`). It interprets CI status using canonical message definitions from the `cimonitor` package:

- **`ciChecksPassedMsg`** — All checks successful
- **`ciChecksRunningMsg`** — Checks in progress  
- **`ciNoChecksPassedMsg`** — No checks detected

### Auto-Fix and Failure Handling

When checks fail, the system can apply automatic fixes subject to the `auto_fix.ci` configuration limit, or pause for manual intervention. Monitoring terminates when the PR merges, closes, or when the `ci_timeout` duration expires.

## Configuration Options for CI/CD Integration

Configure CI behavior through [`.no-mistakes.yaml`](https://github.com/kunchenguid/no-mistakes/blob/main/.no-mistakes.yaml) or command-line overrides parsed by [`internal/config/config.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/config/config.go). Key parameters include:

- **`ci_timeout`** — Idle timeout for CI monitoring. Set to `0` for the default (7 days), negative values or `"unlimited"` for indefinite monitoring.
- **`auto_fix.ci`** — Maximum automatic fix attempts for CI failures. Set to `0` to disable auto-fix.
- **`checks_grace_period`** — Minimum wait period before treating empty CI results as "no checks" (internal parameter).

## Implementation Examples

### Standalone CI Monitoring

Run no-mistakes directly in a repository with an open pull request:

```bash
no-mistakes run

```

This creates a `CIStep` that watches CI status, reports progress in the terminal UI, and applies auto-fixes if configured.

### Custom Timeout and Auto-Fix Configuration

Create [`.no-mistakes.yaml`](https://github.com/kunchenguid/no-mistakes/blob/main/.no-mistakes.yaml) to set a 2-hour timeout and enable two auto-fix attempts:

```yaml
ci_timeout: "2h"
auto_fix:
  ci: 2

```

Running `no-mistakes run` applies these constraints, terminating after two hours of inactivity or after attempting two automatic fixes.

### GitHub Actions Integration

Invoke no-mistakes from existing CI workflows to enforce safety gates:

```yaml

# .github/workflows/ci.yml

name: Verify PR with no-mistakes
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  no-mistakes:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Install no-mistakes
        run: go install ./cmd/no-mistakes
      - name: Run CI monitor
        env:
          NM_HOME: ${{ runner.temp }}/nm-home
        run: no-mistakes run --ci-timeout=30m

```

This workflow runs no-mistakes as a pre-merge gate, monitoring the same PR's CI checks and aborting if timeouts occur or unrecoverable failures remain.

## Summary

- The `CIStep` in [`internal/pipeline/steps/ci.go`](https://github.com/kunchenguid/no-mistakes/blob/main/internal/pipeline/steps/ci.go) provides native CI/CD integration by polling provider APIs directly.
- No external CI orchestration is required—run `no-mistakes` in any clone with an open PR to monitor pipeline status.
- Configuration through [`.no-mistakes.yaml`](https://github.com/kunchenguid/no-mistakes/blob/main/.no-mistakes.yaml) supports custom timeouts (`ci_timeout`) and automatic failure recovery (`auto_fix.ci`).
- The tool integrates with GitHub Actions, GitLab CI, and Bitbucket Pipelines through provider-specific implementations in `internal/scm/`.
- Both standalone execution and embedded CI workflow invocation are supported deployment patterns.

## Frequently Asked Questions

### Does no-mistakes require a specific CI provider to work?

No. The tool detects your provider automatically using `scm.DetectProvider` and includes dedicated API clients for GitHub, GitLab, and Bitbucket in `internal/scm/`. It communicates directly with provider APIs, making it provider-agnostic regarding CI/CD platforms.

### How does no-mistakes handle long-running CI pipelines?

The `ci_timeout` configuration parameter controls idle timeouts. By default, monitoring continues for 7 days, but you can specify `"unlimited"` for indefinite monitoring or set specific durations like `"2h"`. The polling loop re-arms the timeout whenever the default branch advances.

### Can I disable automatic fixes for CI failures?

Yes. Set `auto_fix.ci` to `0` in [`.no-mistakes.yaml`](https://github.com/kunchenguid/no-mistakes/blob/main/.no-mistakes.yaml) to disable automatic fixes. When disabled, the tool pauses and waits for manual intervention upon detecting CI failures rather than attempting recovery.

### Is it possible to run no-mistakes inside existing GitHub Actions workflows?

Absolutely. You can invoke `no-mistakes run` from any CI system, including GitHub Actions, GitLab CI, or Bitbucket Pipelines. Simply install the binary and execute it with appropriate timeouts to enforce pre-merge gates without modifying your existing pipeline structure.