← Back to Home

no-mistakes — Self-Hosted AI-Powered Git Gate for Clean Pull Requests

no-mistakes — Self-Hosted AI-Powered Git Gate for Clean Pull Requests

Getting a pull request ready takes more than just writing code. You need to rebase, review, test, update docs, lint, and make sure CI won't immediately fail. Most of this validation happens after the push — when the branch is already public and the CI queue is filling up.

no-mistakes flips that model. It inserts a local git proxy between your working tree and your remote. Push to no-mistakes instead of origin, and it spins up a disposable worktree, runs an AI-driven validation pipeline, and only forwards the branch to your configured push target once every check passes. The result: clean PRs, every time.

Created by Kun Chen (former engineer at Meta, Microsoft, and Atlassian), no-mistakes is written in Go and licensed under MIT. It supports Claude, Codex, Rovo Dev, Opencode, Pi, and Copilot as validation agents.

Why It's Trending

AI coding agents can produce code faster than any team can validate it. The bottleneck has shifted from writing diffs to reviewing and testing them. no-mistakes sits exactly in that gap — a deliberate local gate that runs the full validation suite before the branch becomes public.

With 3,500+ GitHub stars in under three months, it's resonating with teams that want systematic PR quality without relying on cloud CI for every check.

Architecture Overview

no-mistakes Architecture

The architecture follows a clean pipeline model:

  1. Your repo — push to the no-mistakes remote (a local bare repo) instead of origin
  2. Post-receive hook — fires when the push lands, notifies the background daemon
  3. Daemon — background process that manages pipeline runs, worktrees, and agent orchestration
  4. Disposable worktree — an isolated Git worktree where the pipeline runs without touching your working directory
  5. Pipeline — nine steps in fixed order: Intent → Rebase → Review → Test → Document → Lint → Push → PR → CI
  6. Push target — only after all checks pass does the daemon forward the branch to the real remote and open a PR

All of this runs locally. There is no dependency on a remote CI service for the core validation.

Prerequisites

  • Linux, macOS, or Windows
  • Git
  • One supported AI agent: claude, codex, acli (Rovo Dev), opencode, pi, or copilot
  • gh CLI (GitHub) or glab CLI (GitLab) for PR/CI integration (optional)

Installation

The recommended install method is the official one-liner:

curl -fsSL https://raw.githubusercontent.com/kunchenguid/no-mistakes/main/docs/install.sh | sh

This drops the binary in ~/.no-mistakes/bin, creates a symlink in ~/.local/bin, and restarts the background daemon. On macOS it uses launchd; on Linux it uses a systemd user service.

Go install (for those who prefer building from source):

go install github.com/kunchenguid/no-mistakes@latest

Verify the installation:

no-mistakes --version

Quick Start

1. Initialize a Repository

Navigate to any Git repo with an origin remote:

cd /path/to/your/project
no-mistakes init

This creates:

  • A local bare gate repo at ~/.no-mistakes/repos/<id>.git
  • A no-mistakes Git remote in your working repo
  • A post-receive hook that notifies the daemon on each push
  • A /no-mistakes skill file for Claude Code / Codex

2. Push Through the Gate

Instead of git push origin, push to the gate:

git checkout -b feature/my-feature
# make changes, commit...
git push no-mistakes

The daemon picks up the push, creates a disposable worktree, and starts the pipeline.

3. Watch the Pipeline

no-mistakes

This opens the TUI where you see each step's progress, stream agent output, and approve/fix/skip findings. Steps that can auto-fix will do so (up to a configurable limit per step).

4. Let Your Agent Drive (Agent Mode)

If you're inside Claude Code or Codex, use the /no-mistakes skill:

/no-mistakes add a --json flag to the status command

The agent inspects scope, commits changes to a feature branch, gates them through the pipeline, and reports findings.

Pipeline Steps

The pipeline runs these nine steps in strict order:

Step What it does Auto-fix limit
Intent Use agent-supplied intent or infer from recent local agent transcripts
Rebase Fetch fresh upstream, rebase your branch, raise findings if local default commits aren't pushed 3
Review AI code review of your diff 0 (requires approval)
Test Run baseline tests and gather evidence for available intent 3
Document Update docs when needed and report unresolved gaps initial pass
Lint Run lint/static analysis 3
Push Safely push the validated branch to the configured target
PR Create or update the pull request
CI Watch CI + mergeability, auto-fix failures 3

Only after all local checks pass does the gate push the branch and open the PR. If CI fails, it loops back through auto-fix attempts.

Configuration

no-mistakes supports global and per-repo configuration. The config file is at ~/.no-mistakes/config.yaml globally and .no-mistakes.yaml per repo.

Key configuration options:

  • Agent selection: Set the default agent with agent: (e.g., claude, codex)
  • Auto-fix limits: Per-step limits for how many auto-fix iterations to attempt (e.g., review.auto_fix: 3)
  • Provider integration: Configure GitHub, GitLab, or Bitbucket for PR and CI
  • Lint commands: Override the default lint step with custom commands
  • Telemetry: Set NO_MISTAKES_TELEMETRY=0 to disable usage telemetry

Example per-repo config:

agent: claude
steps:
  review:
    auto_fix: 1
  test:
    auto_fix: 3
  lint:
    auto_fix: 1

Fork Workflow

For GitHub fork contributions, keep origin pointed at the parent repository and initialize with:

no-mistakes init --fork-url git@github.com:you/my-fork.git

The gate pushes validated branches to your fork while opening PRs against the parent. Regular git push origin still works for direct pushes.

Verification Checklist

  • no-mistakes doctor reports all prerequisites green
  • no-mistakes init creates the gate remote and agent skill
  • git push no-mistakes <branch> triggers the pipeline in a worktree
  • The TUI opens and shows pipeline progress
  • Findings pause for approval (review, test, doc, lint)
  • Branch reaches origin only after all checks pass
  • PR is opened automatically with clean description
  • CI failures trigger auto-fix loops

Resources

← Retour à l'Accueil

no-mistakes — Porte Git Locale Alimentée par l'IA pour des Pull Requests Propres

no-mistakes — Porte Git Locale Alimentée par l'IA pour des Pull Requests Propres

Préparer une pull request demande plus que simplement écrire du code. Il faut rebaser, reviewer, tester, mettre à jour la documentation, linter et s'assurer que la CI ne va pas échouer immédiatement. La plupart de cette validation se produit après le push — quand la branche est déjà publique et que la file d'attente CI se remplit.

no-mistakes inverse ce modèle. Il insère un proxy Git local entre votre arbre de travail et votre dépôt distant. Poussez vers no-mistakes au lieu d'origin, et il crée un worktree jetable, exécute un pipeline de validation piloté par IA, et ne transmet la branche à votre cible configurée qu'après que chaque vérification a réussi. Résultat : des PR propres, à chaque fois.

Créé par Kun Chen (ancien ingénieur chez Meta, Microsoft et Atlassian), no-mistakes est écrit en Go et sous licence MIT. Il supporte Claude, Codex, Rovo Dev, Opencode, Pi et Copilot comme agents de validation.

Pourquoi C'est Tendance

Les agents de codage IA peuvent produire du code plus vite que n'importe quelle équipe ne peut le valider. Le goulot d'étranglement s'est déplacé de l'écriture des diffs vers la revue et les tests. no-mistakes se place exactement dans cet espace — un portail local délibéré qui exécute la suite complète de validation avant que la branche ne devienne publique.

Avec plus de 3 500 étoiles GitHub en moins de trois mois, l'outil trouve un écho auprès des équipes qui veulent une qualité de PR systématique sans dépendre du cloud CI pour chaque vérification.

Architecture

Architecture no-mistakes

L'architecture suit un modèle de pipeline simple :

  1. Votre dépôt — poussez vers le remote no-mistakes (un bare repo local) au lieu d'origin
  2. Hook post-receive — se déclenche quand le push arrive, notifie le daemon en arrière-plan
  3. Daemon — processus d'arrière-plan qui gère les exécutions du pipeline, les worktrees et l'orchestration des agents
  4. Worktree jetable — un worktree Git isolé où le pipeline s'exécute sans toucher à votre répertoire de travail
  5. Pipeline — neuf étapes dans un ordre fixe : Intent → Rebase → Review → Test → Document → Lint → Push → PR → CI
  6. Cible de push — seulement après que toutes les vérifications passent, le daemon transmet la branche au vrai remote et ouvre une PR

Tout cela s'exécute en local. Il n'y a aucune dépendance à un service CI distant pour la validation principale.

Prérequis

  • Linux, macOS ou Windows
  • Git
  • Un agent IA supporté : claude, codex, acli (Rovo Dev), opencode, pi ou copilot
  • CLI gh (GitHub) ou glab (GitLab) pour l'intégration PR/CI (optionnel)

Installation

La méthode d'installation recommandée est l'installation officielle en une ligne :

curl -fsSL https://raw.githubusercontent.com/kunchenguid/no-mistakes/main/docs/install.sh | sh

Cette commande place le binaire dans ~/.no-mistakes/bin, crée un lien symbolique dans ~/.local/bin et redémarre le daemon d'arrière-plan. Sur macOS, elle utilise launchd ; sur Linux, un service utilisateur systemd.

Installation Go (pour ceux qui préfèrent compiler depuis les sources) :

go install github.com/kunchenguid/no-mistakes@latest

Vérifiez l'installation :

no-mistakes --version

Démarrage Rapide

1. Initialiser un Dépôt

Placez-vous dans un dépôt Git avec un remote origin :

cd /chemin/vers/votre/projet
no-mistakes init

Cette commande crée :

  • Un dépôt bare local pour la porte dans ~/.no-mistakes/repos/<id>.git
  • Un remote Git no-mistakes dans votre dépôt de travail
  • Un hook post-receive qui notifie le daemon à chaque push
  • Un fichier de compétence /no-mistakes pour Claude Code / Codex

2. Pousser à Travers la Porte

Au lieu de git push origin, poussez vers la porte :

git checkout -b feature/ma-fonctionnalite
# faites des modifications, commitez...
git push no-mistakes

Le daemon récupère le push, crée un worktree jetable et démarre le pipeline.

3. Observer le Pipeline

no-mistakes

Ceci ouvre l'interface TUI où vous voyez la progression de chaque étape, les sorties des agents en continu, et approuvez/corrigez/ignorez les constats. Les étapes qui le peuvent appliquent des correctifs automatiques (jusqu'à une limite configurable par étape).

4. Laisser Votre Agent Piloter (Mode Agent)

Si vous êtes dans Claude Code ou Codex, utilisez la compétence /no-mistakes :

/no-mistakes ajoute un flag --json à la commande status

L'agent inspecte le périmètre, commit les changements sur une branche, les valide via le pipeline, et rapporte les constats.

Étapes du Pipeline

Le pipeline exécute ces neuf étapes dans un ordre strict :

Étape Rôle Limite auto-fix
Intent Utilise l'intention fournie par l'agent ou l'infère des transcripts locaux
Rebase Récupère l'upstream, rebase, signale si des commits locaux ne sont pas poussés 3
Review Revue de code IA de votre diff 0 (approbation requise)
Test Exécute les tests de base avec preuves 3
Document Met à jour la documentation si nécessaire premier passage
Lint Analyse statique et lint 3
Push Pousse la branche validée vers la cible configurée
PR Crée ou met à jour la pull request
CI Surveille CI + mergeability, corrige les échecs 3

Ce n'est qu'après que toutes les vérifications locales passent que la porte pousse la branche et ouvre la PR. Si la CI échoue, elle boucle sur des tentatives de correction automatique.

Configuration

no-mistakes supporte une configuration globale et par dépôt. Le fichier de configuration global est ~/.no-mistakes/config.yaml ; le fichier par dépôt est .no-mistakes.yaml.

Options de configuration clés :

  • Sélection d'agent : Définissez l'agent par défaut avec agent: (ex: claude, codex)
  • Limites auto-fix : Limites par étape pour les itérations de correction automatique
  • Intégration fournisseur : Configurez GitHub, GitLab ou Bitbucket pour PR et CI
  • Commandes lint : Remplacez l'étape lint par défaut par des commandes personnalisées
  • Télémétrie : Définissez NO_MISTAKES_TELEMETRY=0 pour désactiver la télémétrie

Exemple de configuration par dépôt :

agent: claude
steps:
  review:
    auto_fix: 1
  test:
    auto_fix: 3
  lint:
    auto_fix: 1

Flux Fork

Pour les contributions via fork GitHub, gardez origin pointé vers le dépôt parent et initialisez avec :

no-mistakes init --fork-url git@github.com:vous/mon-fork.git

La porte pousse les branches validées vers votre fork tout en ouvrant les PRs contre le dépôt parent.

Liste de Vérification

  • no-mistakes doctor indique que tous les prérequis sont verts
  • no-mistakes init crée le remote de porte et la compétence agent
  • git push no-mistakes <branche> déclenche le pipeline dans un worktree
  • La TUI s'ouvre et montre la progression du pipeline
  • Les constats font une pause pour approbation (review, test, doc, lint)
  • La branche atteint origin seulement après que toutes les vérifications passent
  • La PR est ouverte automatiquement avec une description propre
  • Les échecs CI déclenchent des boucles de correction automatique

Ressources