no-mistakes CLI
A local gate in front of git push: the branch goes through review, tests, docs and lint in a separate worktree before it reaches the remote with a PR
- 8,914 ★ on the repository
- Last commit
- MIT
Broad access
Why this level
- The pipeline agent reads the whole branch diff, runs tests and lint and edits the code itself
- The gate pushes the branch to the remote, opens a PR and uses a guarded force-push to repair CI
- A background process runs permanently as a system service and keeps runs in a local database
Install
- Works in
Manual install
curl -fsSL https://raw.githubusercontent.com/kunchenguid/no-mistakes/main/docs/install.sh | shFor macOS and Linux. The binary goes to ~/.no-mistakes/bin and the background process starts right away. Windows has install.ps1, Go has go install, and Nix builds from the flake.
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- The pipeline agent reads the whole branch diff, runs tests and lint and edits the code itself
- The gate pushes the branch to the remote, opens a PR and uses a guarded force-push to repair CI
- A background process runs permanently as a system service and keeps runs in a local database
This is third-party code. Review the repository files before installing.
What it does
no-mistakes puts a local git proxy between you and the remote repository. Running `no-mistakes init` in a repository creates a gate under `~/.no-mistakes/repos/`, adds a `no-mistakes` git remote and installs the `/no-mistakes` skill for agents at user level. Instead of `git push origin` you run `git push no-mistakes`: a hook hands the branch to a background process and returns at once, while the checks run in a separate temporary worktree without disturbing your work. The pipeline has nine steps: `intent`, `rebase`, `review`, `test`, `document`, `lint`, `push`, `pr`, `ci`. Review, test discovery and runs, documentation updates and fixes are done by the configured agent: Claude, Codex, Grok Build, Antigravity, Rovo Dev, OpenCode, Pi or Copilot, with Cursor and Devin attached through `acpx`. Safe mechanical fixes apply on their own, while anything touching your intent stops as a finding where you choose to approve, fix or skip. The branch reaches the remote only after every local step is green. Then the gate opens a PR and watches CI, and tries to repair it if CI fails. There are three ways to start a run. `git push no-mistakes` sends a committed branch. Plain `no-mistakes` opens a terminal interface that offers to create a branch, a commit and the push, and with `-y` does all of it by itself. `/no-mistakes <task>` inside an agent has it do the task and pass the result through the gate; under the hood the skill calls `no-mistakes axi`.
Who it is for. For developers who ship agent-written changes and want the branch checked automatically before it lands in the shared repository.
Good fit when
- An agent writes a lot of code and you need a mandatory review, test and lint pass before pushing
- You are tired of writing PR descriptions by hand and waiting on CI only to fix its failures
- You want to hand a task to an agent and get a result that has already been checked
- You contribute to someone else's repository from a fork and want PRs against the parent from a checked branch
- The team wants to require that PRs go through the gate; the repository ships a GitHub action, `require-no-mistakes`, for that
Not a fit when
- There is no supported agent on the command line: every gate run needs a configured pipeline agent
- You need checks without sending code to an agent: a model performs review, tests and fixes, and the branch code reaches its provider
- You only want a quick pre-commit hook: the gate runs the full nine-step pipeline, which takes longer than a plain hook
- You only want a review of an existing PR without pushing a branch: open-code-review is closer
Example request
/no-mistakes add a phone number format check to the order form and pass the changes through the gateLimitations
The license is MIT. It runs on macOS, Linux and Windows; the Nix build covers x86_64-linux, aarch64-linux and aarch64-darwin, and Intel macOS is not included.
- Installation starts a background process: a launchd service on macOS, a systemd user service on Linux, a Task Scheduler task on Windows, and a detached process where that path is unavailable.
- Official builds send telemetry to the author's own Umami server: command names, statuses, durations and counts. Agent prompts, diffs, paths and branch names are not included. `NO_MISTAKES_TELEMETRY=0` turns it off, and a `go install` build sends nothing by default.
- The install script creates a link in `/usr/local/bin` through `sudo` when `~/.local/bin` is not on `PATH`.
- The worktree boundary rests on instructions to the agent, not on process isolation: the documentation itself calls it prompt steering.
- Test and lint commands are found by the agent unless you set `commands.test` and `commands.lint` in the repository.
How to disable. `no-mistakes eject` in a repository removes the `no-mistakes` remote, the gate, its worktrees and the database record. `no-mistakes daemon stop` stops the background process, and `no-mistakes daemon uninstall` removes its service.
FAQ
What does it mean that a branch passed the gate?
The branch was checked against the fresh remote, review, tests, docs and lint ran before the push, and every check the repository declared completed. The final branch update is guarded against discarding other people's commits on the push target.
Which steps can be skipped?
The order of the nine steps is fixed, but a run can start with `--skip` and a comma-separated list of steps. A repository adds its own checks through a `gates` block in `.no-mistakes.yaml`, and those cannot remove or reorder the core steps.
What if I work from a fork on GitHub?
Keep `origin` pointed at the parent repository and run `no-mistakes init --fork-url <your fork address>`. Branches then go to the fork and PRs open against `origin`.
How do I check that the gate sees the right agent?
Run `no-mistakes doctor`. By default `agent: auto` takes the first supported agent found on the system, and you can set an ordered list of fallbacks in the config.
What else does the tool do besides running the pipeline?
`no-mistakes runs` and `no-mistakes status` list runs, `no-mistakes rerun` repeats them, `no-mistakes stats` prints agent call counts and tokens from the local database, and `no-mistakes eval` runs evaluation scenarios. `no-mistakes ci-workflow` creates a GitHub Actions workflow file.
Discussion
No questions or reviews yet.
Related
CLI toolsprek skill for agents
prek skill
The prek skill teaches an agent to set up Git hooks with prek, a Rust replacement for pre-commit: config, shims, priorities, built-in hooks and monorepos
A Git merge driver and MCP server that compares functions and classes and removes false conflicts from parallel agent edits
A git worktree CLI built for running Claude Code and Codex in parallel: the wt command, a plugin, and automation hooks
A GitHub CLI wrapper for agents: compact TOON output, next-step hints and structured errors for issues, PRs, CI and releases
A GitLab MCP with 86 tools: issues, merge requests, pipelines, wikis and files, a read-only mode and a launch both locally and remotely with OAuth
A pattern library and skill set for recurring agent loops: issue triage, dependency cleanup, PR babysitting
Comparison with similar tools
Entries that share the main search query, and how they differ.
| Entry | Official | Repository stars | Main difference |
|---|---|---|---|
| no-mistakes (this entry) | no | 8,914 | |
| open-code-review | no | 47,758 | reads a git diff and writes line-level comments, does not push the branch or open a PR |
| PR Lens | no | 2,159 | draws an architecture and data-flow diagram in the PR description, does not run checks or tests |
README in short
The description comes in English and Chinese. It opens with the idea of the gate and a list of properties: background work, agent independence, an agent skill and decisions left to the human. Next come a pipeline diagram, a paragraph on how the gate repairs CI and when it repeats review, a one-command install, a first-run example showing the `init` output and the three ways to start a run. Detailed documentation lives on the project site, and the repository holds the Go source, tests, speed measurements in `benchmarks/`, the `VISION.md` and `CONTRIBUTING.md` documents and the gate's own `.no-mistakes.yaml` config.