no-mistakes: An AI Git Gate for Clean PRs
kunchenguid/no-mistakesno-mistakes is a Go git gate that sits between your branch and your real remote: instead of `git push origin`, you push to `no-mistakes`, which spins up a disposable worktree and runs an AI-driven pipeline — review, test, docs, lint — before forwarding the branch and opening a PR. Nothing reaches your push target until every check is green.
Reach for no-mistakes if you ship a lot of AI-generated code and want a checkpoint that catches slop before it lands in a PR — it runs review, test, lint, and docs checks in an isolated worktree and only forwards the branch once everything passes. Skip it if you don't already run a coding agent like Claude or Codex, because every gate needs one and each run spends real API tokens; for deterministic lint-and-test checks, a plain pre-commit hook is cheaper.
The problem it solves
Coding agents produce a lot of output fast, and not all of it is clean — half-finished edits, skipped tests, stale docs, lint noise. Reviewing all of that by hand before every push is tedious, and pushing straight to `origin` means the mess lands in a PR where a human reviewer has to catch it. There's no standard checkpoint between 'the agent finished' and 'this is ready for review.'
What is it?
no-mistakes is an open-source (MIT) Go tool that acts as a git gate — a local git proxy you push to instead of `origin`. When you run `git push no-mistakes`, it creates a disposable worktree, runs an AI-driven validation pipeline (review → test → docs → lint), and only forwards your branch to the configured push target once every step passes, then opens the PR for you. It's agent-agnostic, working with claude, codex, opencode, copilot and others, and can be driven three ways: the git push, an interactive TUI, or a `/no-mistakes` skill your coding agent calls directly.
Why it's getting attention
It targets the 'AI slop' problem head-on — the repo's own tagline is 'Kill all the slop. Raise clean PR.' As more teams let coding agents write code, a checkpoint that gates that output before it reaches a PR is timely. The README carries a Trendshift badge, and per its GitHub metadata the project has drawn close to 5,900 stars; it also works with the popular agents (claude, codex, opencode, copilot) rather than locking you to one.
Key features
- ✓A local git proxy: push to the `no-mistakes` remote instead of `origin`, and it gates the branch before anything reaches your real remote
- ✓Runs the pipeline in a disposable worktree, so your working tree stays untouched while checks run
- ✓AI-driven validation stages — review, test, docs, lint — followed by push, PR creation, and CI watching
- ✓Agent-agnostic: works with claude, codex, rovodev, opencode, pi, copilot, or an acp target via acpx, with ordered fallbacks
- ✓Auto-applies safe, mechanical fixes and escalates anything that touches your intent for you to approve, fix, or skip
- ✓Three entry points to the same pipeline: `git push no-mistakes`, an interactive TUI, or the `/no-mistakes` agent skill
- ✓Opens a clean PR automatically once every check is green — no manual `git push origin` and no hand-written PR body
Best use cases
- •Gating AI-generated branches so unfinished edits, skipped tests, or stale docs get caught before they reach a PR
- •Letting a coding agent run a task and self-gate it headlessly via the `/no-mistakes` skill
- •Standardizing a pre-PR checklist (review, test, lint, docs) across a team without wiring separate CI steps for each
- •Producing consistently clean PRs with generated bodies instead of hand-writing each one
How to install / try
On macOS or Linux, install with the one-line script from the repo: `curl -fsSL https://raw.githubusercontent.com/kunchenguid/no-mistakes/main/docs/install.sh | sh`. The README points to a separate installation guide for Windows, `go install`, and building from source. After installing, run `no-mistakes init` in a repo to set up the gate remote and install the `/no-mistakes` skill for your agents.
How to use
Initialize once with `no-mistakes init`, then work on a branch as usual. When you're ready, run `git push no-mistakes` to send the branch through the gate, or just run `no-mistakes` to open the TUI (it can create the branch, commit, and push for you). From the TUI you act on each finding — auto-fix ones are applied, judgement calls you approve, fix, or skip. Once every check is green, the gate forwards your branch and opens the PR. An agent can drive the same flow with `/no-mistakes <task>`.
Strengths
- ✓Puts a real checkpoint between agent output and a PR, instead of relying on a human reviewer to catch slop after the fact
- ✓The disposable-worktree design means checks run without disrupting your working tree
- ✓Not tied to one agent — claude, codex, opencode, copilot and others all work, with ordered fallbacks
- ✓Three entry points (git push, TUI, agent skill) cover both manual and headless workflows from the same pipeline
- ✓MIT-licensed and cross-platform (macOS, Linux, Windows), written in Go
Limitations & risks
- △Every gate needs a configured, runnable coding agent (claude, codex, opencode, etc.) — without one there's no pipeline, and each run spends real API tokens and time
- △The validation is AI-driven and therefore non-deterministic: the same branch can surface different findings across runs, and the agent can raise false positives or miss real problems
- △It changes how you push — you send branches to a `no-mistakes` remote and work a findings/TUI flow instead of `git push origin`, which is a learning curve for you and any collaborators
- △Setup leans on a `curl | sh` install script (Windows and source builds are documented separately), and the project is young enough that the workflow may still shift
Alternatives
Who should try it — and who should skip
Developers and teams who lean on coding agents (Claude, Codex, opencode, Copilot) and want a consistent gate between generated code and a PR. If you already run an agent and push a lot of machine-written branches, the pre-PR pipeline earns its keep. If you don't use a coding agent, or you only need deterministic lint-and-test hooks, a plain pre-commit setup is simpler and free.
Frequently asked questions
no-mistakes is an open-source Go tool that acts as a git gate: you push a branch to a local `no-mistakes` remote instead of `origin`, it runs an AI-driven review/test/docs/lint pipeline in a disposable worktree, and only forwards the branch and opens a PR once every check passes.
It puts a local git proxy in front of your real remote. `git push no-mistakes` spins up a throwaway worktree, runs the pipeline, auto-applies safe fixes, escalates anything that touches your intent, and forwards to your push target only when everything is green.
Per the README it's agent-agnostic — claude, codex, rovodev, opencode, pi, copilot, or an acp target via acpx, with ordered fallbacks. Every gate requires at least one runnable, configured agent.
Not exactly. It runs checks before the PR and can watch CI and auto-fix failures after opening it, but it depends on a coding agent to run the pipeline and still pushes to your normal remote and CI. Treat it as a pre-PR gate layered on top of your existing setup.
The tool is MIT-licensed and open source, but the pipeline runs through a coding agent, so each gate consumes whatever API quota or tokens that agent uses.