You're pushing branches faster than you can review them. That's the new reality. AI agents write code faster than humans read it, and the bottleneck has quietly shifted — it's no longer writing code, it's validating it before it lands somewhere public.

no-mistakes is a local git proxy that intercepts your push before it reaches origin. You configure it once per repo, then push to the no-mistakes remote instead of origin. It spins up a disposable worktree, runs a validation pipeline — AI code review, tests, docs, lint, rebase onto fresh upstream — then forwards your branch and opens the PR automatically. Only if everything passes.

What It Actually Does

The pipeline isn't just formatting. Here's what runs before anything reaches your remote:

  • Rebase onto fresh upstream (no merge conflicts landing in the PR)
  • AI code review via whichever agent you have configured
  • Tests — regression + new tests executed
  • Documentation — keeps docs aligned with code changes
  • Lint and formatting — done before push, not after
  • PR creation — opened automatically once the branch is clean

Safe, mechanical fixes get applied without asking. Anything that touches intent gets escalated to you. The human stays in the loop, but only for the decisions that actually need a human.

Installation

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

Windows, Go install, and build-from-source options are in their installation guide.

Setup

In your repo:

no-mistakes init

This sets up a local git remote called no-mistakes and optionally installs the /no-mistakes skill for Claude Code and other agents. You'll see something like:

✓ Gate initialized

  repo  /home/you/src/my-repo
  gate  no-mistakes → /home/you/.no-mistakes/repos/abc123def456.git
  remote  [email protected]:you/my-repo.git
  skill  /no-mistakes installed for agents at user level

Push through the gate with:
  git push no-mistakes <branch>

Using It

The swap is just the remote name:

git push no-mistakes my-branch

Then run no-mistakes to open the TUI and watch the pipeline. Findings come up one by one — auto-fixable ones are handled for you (or you approve them), judgment calls are flagged for you to decide on. Once everything is green, the gate pushes your branch to origin and opens the PR.

If you're working with a coding agent, the agent skill makes this fully headless:

/no-mistakes

The agent drives the entire flow — pipeline runs, fixes what it safely can, escalates the rest, pushes the branch.

For GitHub fork contributions, there's an extra flag:

no-mistakes init --fork-url <your-fork-url>

The Honest Downsides

This is early software. A few things to know going in:

Agent quality is the ceiling. The AI review step is only as good as the agent you've configured. A mediocre model running review is still a mediocre review — just earlier in the process. The gate amplifies your agent, it doesn't replace judgment.

Configuration overhead. Per-repo setup is fast, but if you're across dozens of repos, no-mistakes init gets repetitive. There's no global default that just works everywhere.

The pipeline isn't fully customizable yet. The steps run in a fixed order and with fixed logic. If your project has unusual test setups or build requirements, you may hit friction. Check their docs and GitHub issues before committing to it on something critical.

It's a local process. The disposable worktree runs on your machine. If you close your laptop mid-push, you're interrupting the pipeline. Not a dealbreaker, but worth knowing.

Verdict

The core insight here is correct: quality infrastructure should live closer to where you're working, not only in the outer CI/CD loop after the branch is already public. no-mistakes acts on that insight with a clean implementation — isolated worktrees, non-blocking pipeline, works with the agents you're already using.

If you're shipping AI-generated code at any real velocity, this is worth the setup time. It's most valuable when you're doing rapid iteration with an agent and want something between "push and pray" and "full code review every time."

It won't replace a thoughtful reviewer on your team. It will catch the obvious stuff before that reviewer ever sees the branch — which is exactly what you want.

Try It

no-mistakes init

Start there. Push a branch through the gate, watch what it catches. The project is at github.com/kunchenguid/no-mistakes and the full docs are at kunchenguid.github.io/no-mistakes.