mrkeyoor.com_
Tue 01 Sept 17:45 UTC
Dev Toolsevaluationupdated 26 Aug 2026

no-mistakes review

No Mistakes is a local Git gate that checks work in a disposable worktree before it reaches the real remote. It uses a configured coding agent to review, test, document, lint, repair, push, open a pull request, and watch CI, while asking a person to decide changes that may affect intent.

+353stars / 7d
Verdict

Our No Mistakes run built in 41 seconds but finished with 16 of 17 tests passing, so this Git gate is not ready to become the only authority between a branch and its remote. Its isolated workflow is useful for supervised agent review, especially for solo developers already using Claude Code or Codex. Keep protected branches, independent CI, review every generated diff, and pilot gate storage on a low-risk repository.

We ran it

Lab card: what happened when we ran no-mistakesScreenshot of no-mistakes (kunchenguid.github.io/no-mistakes)
Install✓ · 32s67 packages
Build✓ · 41s
Tests✗ · 783s16 passed · 1 failed of 17 (go test)
Repo744 files~202,065 lines of source · 9 MB · 5 CI workflows

Answers from our run

Does no-mistakes build from source?

Dependencies installed in 32 seconds (67 packages), and the build succeeded in 41 seconds. We cloned commit c2a75d0 into a clean Debian container with 3 CPUs and no project-specific setup.

Do no-mistakes's tests pass?

Not all of them: 16 of 17 passed and 1 failed when we ran the project's own test command (go test). Some failures need services or credentials a bare container does not have.

Who should not use no-mistakes?

Teams that need every checked commit to pass the project's own suite: our run ended with 16 of 17 tests passing and a final FAIL, while the supplied log tail did not name the failed package.

What are the alternatives to no-mistakes?

pre-commit, reviewdog, Lefthook. Our No Mistakes run built in 41 seconds but finished with 16 of 17 tests passing, so this Git gate is not ready to become the only authority between a branch and its remote.

Setup3/5Fast binary setup, then agent, GitHub, and repo command wiring
Docs4/5Clear workflow and commands with a dedicated documentation site
Community4/5Rapid releases and active issue traffic around a young tool
Maturity2/5Core gate semantics still have consequential open reports

Discussed on

  1. hnShow HN: Git Push No-Mistakes19 points

Who it’s for

Developers who already use Claude Code, Codex, OpenCode, Cursor, or another supported agent and want a repeatable pre-push review flow.
Solo maintainers who want review, tests, documentation, lint, PR creation, and CI follow-up coordinated from one local tool.
Teams willing to treat AI findings as advice and inspect every generated source change.
Contributors who want checks to run in an isolated worktree without interrupting their current checkout.

Who it’s NOT for

Teams that need every checked commit to pass the project's own suite: our run ended with 16 of 17 tests passing and a final FAIL, while the supplied log tail did not name the failed package.
Organizations that forbid generated source changes without diff approval: open issue 725 says a successful test-step auto-fix can complete without presenting the fixer's diff.
Developers with complex worktree layouts who cannot risk repository configuration damage: open issue 845 reports core.bare=true being written into a real repository and breaking about 24 linked worktrees.
Cost-sensitive users running high-effort agents unattended: issue 683 documents 27 review rounds and 8.2 hours because the repair loop had no stopping rule.
Teams unwilling to give an agent code access plus permission to run commands, create commits, push branches, and open pull requests.

Setup reality

Our sandbox installed 67 Go packages in 32 seconds and built the project in 41 seconds. Tests ran for 783 seconds and failed with 16 passed and 1 failed out of 17. The supplied log tail ends in FAIL after many packages report ok; it does not identify the failed package or cause, so we will not guess.

Every gate needs a runnable supported agent, its authentication and quota, repository-specific commands, and GitHub access for pull requests and checks. no-mistakes init creates the local gate remote and installs the agent skill.

The disposable worktree protects the active checkout, but the tool can modify files, commit, push, and open a PR. Open issue 845 reports a gate-isolation path writing core.bare=true into a real repository, so trial it on a low-risk project before trusting that boundary.

A local Git remote turns agent review into a repeatable gate

No Mistakes creates a local remote named no-mistakes. Push a branch there and the tool copies the work into a disposable worktree, then reviews it, runs repository checks, updates documentation, lints, pushes, opens a pull request, and watches CI. The real remote receives the branch only after the configured steps are green. That is easier to repeat than asking an agent to remember an improvised checklist after every coding task.

The same pipeline has 3 entry points: a Git push, the terminal interface, or an installed /no-mistakes skill. The skill matters for Claude Code, Codex, OpenCode, Cursor, and the other agents named in the README because it gives them a structured approval protocol. Mechanical changes can be fixed, while decisions about intent are supposed to stop for a person to approve, repair, or skip.

A 32-second install still needs agent and GitHub credentials

The published installation can be one shell command, followed by no-mistakes init. That initialization records the actual push target, creates the gate, and installs its coding-agent skill. Source development uses Go and exposes Make targets for builds, race-enabled tests, linting, generated skills, documentation, and an end-to-end suite.

Useful operation needs more than the binary. Every gate requires a runnable agent with authentication and quota. Pull-request creation and CI watching need GitHub access, while each repository must supply dependable test, lint, and formatting behavior. The README warns that re-recording end-to-end fixtures calls real agent CLIs and spends real API quota. Teams should set their own time and cost ceilings before allowing unattended repair rounds.

What happened when we ran it

Our sandbox installed 67 Go packages in 32 seconds, then built commit c2a75d0 successfully in 41 seconds. The checkout contained 744 files, about 202,065 source lines, and occupied 9 MB before installation. That is a modest checkout, though the complete test command took far longer than install and build together.

Tests ended with exit code 1 after 783 seconds. The harness counted 16 passed and 1 failed out of 17. The supplied tail lists successful packages such as internal/scm/gitlab, internal/telemetry, internal/tui, and internal/wizard, then ends with FAIL. It does not show which package or assertion failed, so the defensible finding is limited: the full command did not pass in our stated environment.

We ran the project in an unprivileged Debian container with 3 CPUs, 8 GB of RAM, no secrets, and the Go 1.24 Bookworm image. The scan found 5 CI workflow files, no Dockerfile, and no conventional tests directory. Those facts describe commit c2a75d0. They do not measure agent accuracy, PR quality, or how safely the daemon behaves on a developer's long-lived repository.

Issue 845 puts the isolation claim under pressure

A disposable worktree is the right basic design because an agent can inspect and repair a branch without taking over the active checkout. The boundary still reaches local Git configuration and managed gate repositories. Open issue 845 reports core.bare=true appearing in the shared configuration of a real repository, which broke about 24 linked worktrees with Git's "must be run in a work tree" error.

That report names No Mistakes v1.57.0 and describes repeated occurrences on macOS arm64. Its author traced possible writers and proposed checking that Git's resolved directory exactly matches the intended bare gate before changing configuration. An issue report is not a maintainer-confirmed root cause. It is enough reason to pilot the tool away from a repository with valuable worktrees and to back up Git configuration before adoption.

Generated fixes still need an independent approval path

Open issue 725 describes another narrow but serious path: a test-step fixer changes the worktree, the rerun becomes clean, and the executor finishes without displaying the generated diff at the existing review gate. That contradicts the README's promise that changes affecting intent stay under human control. Until fixed and verified, every pushed commit needs review outside No Mistakes itself.

Long loops can also turn supervision into a quota problem. Issue 683 documents one run reaching 27 full rereviews and 8.2 hours under a high-effort agent. The report says most findings were new rather than repeated, so a clean final round never arrived. Put a hard limit on rounds, elapsed time, and spend. A branch that keeps attracting fresh repairs should return to a human instead of continuing overnight.

Version 1.57.0 is active, but activity is not proof of safety

GitHub showed 7,866 stars and 131 combined open issues and pull requests when fetched. The repository was pushed on August 26, 2026. Release v1.57.0 arrived on August 22 with Antigravity support, unified model and effort settings, timeouts around agent calls, branch-custody fixes, and a fail-closed change for invalid pull-request listings.

That release pace and same-day activity show active maintenance. They also mean an operating team should pin the binary and read changes before upgrading a tool that controls Git remotes and agent execution. Five CI workflows and a documented end-to-end fixture process are encouraging, yet our own 783-second suite still ended with 1 failure.

No Mistakes is worth a supervised trial when coding agents are already part of the daily workflow. Its local remote and explicit decision states solve a real coordination problem. The failed test run, issue 845's repository-damage report, and the missing diff gate in issue 725 keep it below the standard for an enforcement boundary.

Alternatives

ProjectWhat it isPick it when
pre-commitA mature framework for running deterministic hooks before commits enter a repository.pick this instead when reproducible linters and checks matter more than AI review or automatic PR creation.
reviewdogA CI tool that turns analyzer output into focused pull-request review comments.pick this instead when checks should run in CI and report findings without rewriting code locally.
LefthookA fast cross-platform Git hooks manager for scripted formatting, linting, and tests.pick this instead when you want a small, deterministic local gate with no agent dependency.

What people are saying

  1. [github-trending] kunchenguid/no-mistakes

Sources

  1. No Mistakes README
  2. No Mistakes v1.57.0 release
  3. Analyzer pass-state issue
  4. Auto-fix review-gate issue
  5. Review loop termination issue
  6. Gate isolation and core.bare issue

More dev tools reviews

workmux · v2rayNG · SecLists · hashcat · eslint · fastfetch · the whole board →