[{"_1":2,"_280":-5,"_281":-5},"loaderData",{"_3":4,"_8":9,"_23":24},"root",{"_5":-5,"_6":7},"user","countable",true,"routes/_main",{"_5":-5,"_10":11},"recentPosts",[12,17,20],{"_13":14,"_15":16},"slug","claude-code-agent-teams","title","What Claude Code's Agent Teams Feature Does",{"_13":18,"_15":19},"claude-code-goal-command","How Claude Code's /goal Command Works",{"_13":21,"_15":22},"claude-code-routines-vs-loop","Claude Code Routines vs /loop: What's the Difference?","routes/creators.$handle",{"_25":26,"_27":26,"_28":29,"_30":31,"_32":33,"_278":31,"_279":100},"handle","kunchenguid","displayName","profileUrl","https://github.com/kunchenguid","verified",false,"skills",[34],{"_35":36,"_13":37,"_38":39,"_40":41,"_42":43,"_44":45,"_46":47,"_48":49,"_50":51,"_52":53,"_54":55,"_60":61,"_62":63,"_64":65,"_80":81,"_82":-5,"_83":84,"_85":86,"_87":88,"_89":90,"_91":92,"_93":-5,"_94":95,"_96":26,"_30":31,"_97":31,"_98":86,"_99":100,"_101":86,"_102":86,"_103":104,"_105":106,"_134":135,"_170":171,"_221":222,"_250":251,"_262":263,"_274":275,"_276":277},"id","gh__kunchenguid__no-mistakes__skills-no-mistakes","no-mistakes-kunchenguid","name","No Mistakes","canonicalName","no-mistakes","tagline","Automated validation for safe code changes.","description","Validate your code changes through the no-mistakes pipeline - automated code review, tests, lint, docs, push, PR, and CI - before they reach the configured push target. Use when the user asks to run no-mistakes, gate or ship or validate their changes, push safely, asks you to do a task and then validate it, or invokes /no-mistakes.","longDescription","No Mistakes is a powerful local gate that ensures your code changes are validated through a comprehensive pipeline before they are pushed to your target repository. This tool automates the process of code review, testing, documentation, linting, and continuous integration (CI) to help you maintain code quality and prevent errors from reaching your production environment. By using the `no-mistakes axi` command family, you can easily manage and monitor the validation process, receiving machine-readable output to track progress and outcomes.\n\nThe validation process is structured into distinct phases, allowing you to inspect, fix, and validate your changes methodically. When you invoke the `/no-mistakes` command, you can choose between a validate-only mode or a task-first mode, where you can specify a task for the tool to execute before validating the results. This flexibility makes it suitable for various workflows, whether you are working on a new feature or fixing a bug. The tool emphasizes the importance of committing your changes on a feature branch, ensuring that only relevant modifications are validated and pushed.\n\nOne of the standout features of No Mistakes is its focus on behavior-driven testing. It discourages superficial tests that merely check for the presence of strings or tokens in the code. Instead, it advocates for tests that assert observable behaviors and outcomes, aligning with best practices in software development. This approach not only helps catch regressions but also ensures that your code behaves as intended in real-world scenarios.\n\nNo Mistakes is ideal for developers who prioritize code quality and want to implement a rigorous validation process in their development workflow. It is particularly beneficial for teams practicing continuous integration and delivery, as it integrates seamlessly into existing pipelines, enhancing the overall reliability of the codebase.","primaryCategory","development","subcategory","code-review","secondaryCategories",[],"tags",[56,51,57,58,59],"automated-validation","ci-cd","git","testing","skillType","workflow","complexity","intermediate","platforms",[66,67,68,69,70,71,72,73,74,75,76,77,78,79],"claude-code","claude-api","codex-cli","cursor","antigravity","github-copilot","windsurf","opencode","cline","roo-code","goose","kiro","continue","trae","delivery","source-link","skillFileUrl","pricing","free","price",0,"thumbnailType","icon","thumbnailIcon","check-square","thumbnailColor","green","thumbnailImageUrl","sellerId","gh__kunchenguid","sellerName","featured","downloads","views",1,"rating","reviewCount","status","active","metrics",{"_107":108,"_109":100,"_110":100,"_111":112,"_113":86,"_114":115,"_116":117,"_118":119,"_120":121,"_122":123,"_124":125,"_126":127,"_128":129,"_130":131,"_132":133},"freshnessScore",100,"mirrorCount","skillCountInRepo","qualityScore",85,"daysSinceUpdate","popularityScore",79,"trustScore",65,"repoOpenIssues",194,"repoStars",7554,"repoWatchers",73,"repoContributors",26,"overallScore",82,"repoCreatedAt","2026-04-05T06:43:05Z","repoForks",732,"repoPushedAt","2026-08-11T00:17:09Z","source",{"_136":26,"_137":138,"_139":140,"_145":146,"_147":41,"_148":-5,"_143":149,"_150":151,"_152":146,"_153":31,"_154":155,"_156":157,"_163":164,"_165":7,"_166":167,"_168":169},"owner","repoUrl","https://github.com/kunchenguid/no-mistakes","author",{"_28":29,"_141":142,"_38":26,"_25":26,"_143":144},"avatarUrl","https://github.com/kunchenguid.png","type","User","lastSyncedAt","2026-08-11T01:31:38.366Z","repo","commitSha","github","branch","main","firstSeenAt","isOfficial","path","skills/no-mistakes","license",{"_38":158,"_159":160,"_161":162},"MIT License","spdxId","MIT","url","https://github.com/kunchenguid/no-mistakes/blob/main/LICENSE","sourceUpdatedAt","2026-08-11T00:16:55.000Z","redistributable","permalink","https://github.com/kunchenguid/no-mistakes/blob/main/skills/no-mistakes/SKILL.md","repoFullName","kunchenguid/no-mistakes","seo",{"_172":173,"_184":185,"_186":187,"_205":-5,"_206":207,"_213":214,"_215":216,"_217":218,"_219":220},"useCases",[174,178,181],{"_15":175,"_176":177},"Validating Code Changes","body","Use No Mistakes to validate your code changes before pushing them to ensure they meet quality standards.",{"_15":179,"_176":180},"Integrating into CI/CD Pipelines","Incorporate No Mistakes into your CI/CD pipeline to automate the validation of code changes during the development process.",{"_15":182,"_176":183},"Ensuring Code Quality","Leverage No Mistakes to maintain high code quality by enforcing rigorous testing and validation practices.","whenNotToUse","This skill is not suitable for quick, unreviewed changes or in environments where automated validation is not required.","faqs",[188,193,196,199,202],{"_189":190,"_191":192},"q","What does No Mistakes do?","a","No Mistakes validates your code changes through an automated pipeline that includes code review, testing, linting, and CI before they are pushed to the repository.",{"_189":194,"_191":195},"How do I invoke the No Mistakes skill?","You can invoke No Mistakes using the `/no-mistakes` command, either in validate-only mode or by specifying a task to execute before validation.",{"_189":197,"_191":198},"What are the prerequisites for using No Mistakes?","You must have your changes committed on a feature branch, and the repository should be initialized with `no-mistakes init`.",{"_189":200,"_191":201},"Can No Mistakes run without a CI/CD setup?","No, No Mistakes requires a configured pipeline agent to function properly, and it is designed to integrate with CI/CD workflows.",{"_189":203,"_191":204},"What kind of tests does No Mistakes encourage?","No Mistakes encourages behavior-driven tests that assert observable outcomes rather than superficial checks on code structure.","ogImageUrl","keywords",[208,209,210,211,212],"automated code validation","code review tool","git validation","ci cd integration","linting and testing","whenToUse","Use No Mistakes when you want to validate code changes before pushing them to a repository, especially in CI/CD workflows.","metaTitle","No Mistakes - Automated Code Validation Tool","problemSolved","This tool removes the risk of pushing unvalidated code changes, ensuring higher code quality and fewer errors in production.","metaDescription","Ensure code quality with No Mistakes, an automated validation tool for safe code changes. Click to learn more!","content",{"_223":86,"_224":225,"_233":234,"_243":244,"_245":31,"_246":247,"_249":229},"bundledFiles","fileTree",[226],{"_154":227,"_228":229,"_143":230,"_231":232},"SKILL.md","size",22669,"file","language","markdown","codeExamples",[235,239,241],{"_231":236,"_237":238},"sh","snippet","no-mistakes axi run --intent \"\"",{"_231":236,"_237":240},"# accept the step as-is and continue\n no-mistakes axi respond --action approve\n\n # have the pipeline fix specific findings, then continue\n no-mistakes axi respond --action fix --findings --instructions \"\"\n\n # skip this step\n no-mistakes axi respond --action skip",{"_231":236,"_237":242},"no-mistakes axi # home view: current branch, active runs, next steps\nno-mistakes axi status # full detail plus cached branch_sync when relevant\nno-mistakes axi sync --check # freshly verify an offered synchronization plan\nno-mistakes axi sync # apply only an offered guarded synchronization\nno-mistakes axi sync --recover # return custody after a terminal run left unpublished pipeline commits\nno-mistakes axi logs --step --full # full log output of one step\nno-mistakes axi abort # cancel the current-branch active run\nno-mistakes axi abort --run # cancel a specific run by id (works outside its worktree)","skillMd","# no-mistakes\n\n`no-mistakes` is a local gate that validates your code changes through a pipeline\n(intent, rebase, review, test, document, lint, push, PR, CI) before they reach\nthe configured push target. You drive it through the `no-mistakes axi` command family, which prints\nmachine-readable [TOON](https://toonformat.dev) to stdout and progress to stderr.\n\n\n## Active validation-step boundary\n\nA no-mistakes validation-step agent is already inside an active outer run. It\nmust inspect, fix, and return only its assigned phase. It must never initialize,\nstart, reattach, rerun, respond to, synchronize, abort, eject, or directly push\na no-mistakes pipeline. Delivery requirements in user intent remain\nacceptance context, but the outer executor alone performs the other validation,\npush, PR, and CI phases.\n\n`NO_MISTAKES_GATE` is fast diagnostic evidence, not authorization by\nitself. The runtime combines managed Git identity with authenticated process\nancestry. If a pipeline-control command returns\n`error.code: nested_gate_context`, stop immediately and\nreturn control to the outer executor. Safe inspection remains available through\n`no-mistakes axi status`, `no-mistakes axi logs`, help, and\n`no-mistakes doctor`.\n\n\nWhen the user invokes `/no-mistakes`, report the outcome at the end. If the user\nasks for something specific, translate that request into the matching `axi run`\nflags yourself - for example, \"skip the lint step\" becomes `--skip=lint`. Run\n`no-mistakes axi run --help` to see the available flags.\n\n## Two ways to invoke\n\n`/no-mistakes` works in two modes, depending on whether the user hands you a\ntask along with the command:\n\n- **Validate-only** - bare `/no-mistakes` (optionally with flag-style requests\n like \"skip the lint step\"). The user's code changes are already committed;\n validate them and report the outcome.\n- **Task-first** - `/no-mistakes `, e.g.\n `/no-mistakes add a --json flag to the status command`. First carry out the\n task yourself, then validate the result through the pipeline:\n 1. **Check scope.** Inspect `git status` before you change or commit anything.\n Preserve unrelated pre-existing uncommitted changes, and when you commit,\n commit only the changes that belong to the user's task.\n 2. **Do the work.** Make the changes the task describes, then **commit them on\n a feature branch**. If the user is on the repository's default branch,\n create a feature branch first - the gate validates committed history on a\n non-default branch, so the work must land there before you run.\n 3. **Then validate**, passing the user's task as your `--intent`. The task\n text is exactly what the user set out to accomplish, in their own words, so\n it *is* the intent - preserve requirements stated directly by the user,\n including constraints, exclusions, acceptance criteria, and later decisions;\n do not condense them into a diff summary or drop them while adding\n implementation context. Enrich it with the decisions and tradeoffs you\n made while doing the work (see\n [Intent is required](#intent-is-required)).\n\n\n## Test-quality rule\n\nNever add a test whose only evidence is that it opens, reads, greps, parses, or\nsnapshots implementation source code and finds or omits particular strings,\ntokens, lines, commands, function names, prompt phrases, regex matches, AST\nshapes, or incidental snapshots. That does not prove behavior: matching text\ncan be dead or commented out, and a behavior-preserving refactor can change it.\n\nInstead execute a public or executable interface and assert observable behavior,\nstate, output, side effects, and failure modes. For machine-consumed declarative\nartifacts such as workflow YAML, JSON, policy, .gitignore, or generated\nconfiguration, invoke the real consumer when feasible or parse into a typed or\nnormalized semantic model and assert meaning. A raw substring or regex over the\nfile is still the anti-pattern.\n\nReading a file is legitimate when the file is itself generated public output, a\nserialized protocol, persisted state, an intentional snapshot, or another\nexplicitly owned text or byte contract. Name that contract, and do not use its\ncontents as a proxy that unrelated code works. A natural-language prompt or\ninstruction is not proven effective because its source contains a sentence.\nDeterministic CI may test the final emitted prompt delivered to an agent as an\nintentional generated interface; model interpretation belongs in\ndevelopment-only evaluation, not live-LLM CI.\n\nFor a regression, reproduce the reported failure when feasible: the test should\nfail before the fix and pass after it.\n\n\nEverything below - preconditions, intent, the validate-and-decide loop - applies\nthe same way once the work is committed on a feature branch.\n\n## Before you start\n\n- The work you want validated must be **committed** on a branch. The gate\n validates committed history, not your uncommitted working tree.\n- You must be on a **feature branch**, not the repository's default branch.\n- The repository must already be initialized with `no-mistakes init`.\n- The daemon must have a runnable configured pipeline agent: a supported native\n agent binary, the `agent: cursor` ACP alias, or an explicit `acp:` through\n `acpx`. You are the AXI driver, not\n an implicit pipeline-agent backend. If none is available, the run fails\n before its first step; `no-mistakes doctor` reports the configuration problem.\n\nIf any of these is not met, `axi run` returns an `error:` with the exact command\nto fix it - read it and act on it (commit your work, or create a branch). If the\nrepository is not initialized, run `no-mistakes init` first; if the `no-mistakes`\ncommand itself is missing or misbehaving, `no-mistakes doctor` reports what is\nwrong.\nBefore starting, run `no-mistakes axi` (home view).\nIf it shows an active run on your current branch, inspect it with `no-mistakes axi status`.\nIf it is parked at a gate, drive it with `no-mistakes axi respond`.\nReattach an in-flight run by re-running `no-mistakes axi run` when it still matches your current `HEAD` - either as the submitted head or as the current pipeline head.\nOnly `no-mistakes axi abort` it when you mean to discard that run before starting over; aborting is a between-runs action, never a way to take over or bypass a gate while a run is still going (see [Validate and decide](#validate-and-decide)).\nIf it shows an active run on another branch, leave that run alone and start validation for your current branch with `no-mistakes axi run --intent \"...\"`.\n\n## Intent is required\n\nWhen you start a run you must pass `--intent`: **what the user set out to\naccomplish** - the goal or request behind this work, in their terms. This is not\na description of the diff or the files you changed; it is the objective the\nchange is meant to achieve. You know it from the conversation, so pass it\ndirectly - no-mistakes uses it verbatim instead of inferring it from local agent\ntranscripts (slower and flakier).\n\nErr on the side of completeness, not brevity. The review step uses `--intent`\nto tell a deliberate decision apart from a mistake, so a thin one-line summary\nmakes it flag things the user already chose. Capture the nuance: the user's\ngoal, the specific decisions and tradeoffs they made along the way, any\nconstraints or approaches they ruled in or out, and anything they explicitly\nasked for that might otherwise look surprising in the diff. A few sentences to a\nshort paragraph is normal - write down what you learned from the conversation\nthat a reviewer reading only the diff would not know.\n\n## Validate and decide\n\nRun the pipeline and decide on its findings as they come up:\n\n1. Start the run. It blocks until the first decision point or the end:\n ```sh\n no-mistakes axi run --intent \"\"\n ```\n `axi run` and every `axi respond` block synchronously - the review, test,\n and CI steps can each take **several minutes**, so a single call may not\n return for a while. That is normal; allow a long timeout and do not cancel\n or re-issue the command because it seems slow. To check progress without\n disturbing the run, use `no-mistakes axi status` from a separate call.\n A long-running call is working, not stalled - background it if your harness\n needs to, but the run **never advances past a gate on its own**. Read every\n return; on a `gate:`, respond; loop until an `outcome:`. Never idle-wait\n for the run to move forward by itself.\n When that status output includes `awaiting_agent: parked ` under the run,\n the run is parked at an approval or fix-review gate and waiting for you to\n send `axi respond`. The field is observability only: it does not change\n gate resolution, auto-resume the run, or make `--yes` the default.\n While a step is actively `running` or `fixing`, `axi status` may include\n `active_steps` with `active_for`, `last_activity`, a native `agent_pid` when\n a subprocess agent is running, and the current round such as `round 1`,\n `auto-fix 1/3`, or `fix 2`. If `last_activity` is prefixed with\n `quiet`, no step log or native-agent lifecycle activity has arrived for\n longer than `step_quiet_warning`. Treat that as a liveness clue, not as\n permission to cancel, rerun, or edit the worktree yourself.\n2. If the output contains a `gate:` object, the pipeline is waiting on you.\n Read its `findings` table. Each finding has an `id`, `severity`,\n `file`, `description`, and an `action` that tells you how the\n pipeline classified it:\n - `auto-fix` - mechanical and low-risk; you can authorize the fix on\n your own judgment by responding with `--action fix`.\n - `no-op` - informational only; nothing to do.\n - `ask-user` - the finding challenges the user's deliberate intent or\n touches product behavior. This is a call only the user can make - see\n [Escalate `ask-user` findings](#escalate-ask-user-findings) below.\n\n **Review auto-fix is disabled by default** (`auto_fix.review: 0`; a repo\n or global `auto_fix.review > 0` override re-enables it), so blocking and\n ask-user review findings park for your decision rather than being silently\n self-fixed. (Other steps such as test and lint may auto-fix within the\n pipeline and re-run before they ever gate.)\n\n Choose one response:\n ```sh\n # accept the step as-is and continue\n no-mistakes axi respond --action approve\n\n # have the pipeline fix specific findings, then continue\n no-mistakes axi respond --action fix --findings --instructions \"\"\n\n # skip this step\n no-mistakes axi respond --action skip\n ```\n While a run is active, never fix findings by editing the code yourself -\n the pipeline owns both the findings and the fixes. Your job at a gate is to\n decide and respond; `--action fix` has the pipeline apply the fix and\n re-review the result. For the same reason, while a run is active do **not**\n `abort` or `rerun` to go fix a finding yourself - even a real bug in\n your own code - because that discards the pipeline's in-flight work and\n forces a full re-validation. `abort` and `rerun` are for *between*\n runs (after a `failed` or `cancelled` outcome), never to circumvent a\n gate.\n\n Each `respond` blocks until the next `gate:`, `checks-passed` decision point, or final outcome.\n\n Two extra flags are available on `respond` when you need them:\n - `--add-finding ''` (with `--action fix`) folds a finding you\n spotted yourself - one the pipeline did not surface - into the fix round,\n as a JSON finding object. Use it for a problem you noticed that is not in\n the gate's own `findings` table.\n - `--step ` responds to a specific step instead of the one currently\n awaiting approval. You rarely need this; omit it to answer the active gate.\n3. Repeat step 2 until the output has an `outcome:` instead of a `gate:`. The\n outcomes are:\n - `checks-passed` - the change is validated and CI is green (or the\n trusted default-branch config declares `no_ci: true` and no checks are\n registered - the help line names that declaration when it applies), but\n the PR is not merged yet. **You are done driving the pipeline.** Do not\n wait for the merge: tell the user the PR is ready and ask them to review\n and merge it (the PR link is in the `help` line). A generic empty forge\n check list without that declaration is not ready. no-mistakes keeps\n monitoring the PR in the background until it is merged, closed, or its\n configured idle timeout elapses, so a human can watch it in the TUI.\n - `passed` - the changes cleared the gate and the PR was merged or closed.\n - `failed` or `cancelled` - they did not; read the output and address it.\n Fix whatever the output points at (a failing test, a lint error, a finding\n you skipped), commit the fix on the same feature branch, then drive the\n pipeline again - `no-mistakes axi run --intent \"...\"` starts a fresh run,\n or `no-mistakes rerun` re-runs the pipeline for the current branch. This\n is the right place to start over: a fresh run or `rerun` is a\n *between-runs* action, correct only after a terminal outcome like this -\n never mid-run to circumvent a gate. Do not leave the user at a `failed`\n outcome without either retrying or explaining what blocks it.\n\nBefore any post-pipeline local commit or fresh run, read the structured `branch_sync` object returned by AXI home, status, or a drive result.\nOnly when its `next_action.code` is `sync`, run `no-mistakes axi sync` first.\nThat guarded sync may be a strict fast-forward or a content-equivalent diverged advance that anchors the pre-sync head before moving the branch with reset semantics; genuine divergence stays blocked.\nIf it reports `next_action.code` is `continue_active_run`, the pipeline still owns the branch: run the reported command, keep driving the active run, and do not make local follow-up commits.\nWhen `next_action.code` is `recover_custody`, a terminal run left unpublished pipeline commits preserved in the local gate: run `no-mistakes axi sync --recover` to return custody and take the preserved head, or `no-mistakes rerun` to resume validating it instead.\nRecovery takes that head by fast-forward, or by adopting a diverged preserved head proven to carry every local change - the ordinary result of the pipeline rebasing your commits onto a newer base - after anchoring your pre-recovery head under `refs/no-mistakes/recover-local/`.\nThat proof is deliberately narrow, so a rebase whose fix rounds also rewrote your own lines refuses instead of being adopted: when nothing can tell a deliberate pipeline fix from a dropped change, the decision is yours.\nA `branch_sync.state` of `user_owned` means the run went terminal before changing the submitted head and cancellation released the branch: the exact branch and head are yours and immediately usable for whichever delivery path is authorized - no sync action is needed, and a repeated `--recover` there is a harmless no-op.\nA dirty worktree, or divergence that cannot be proven contained, makes the recovery refuse with explicit choices; `--keep-local` keeps your current head while the preserved commits stay anchored under `refs/no-mistakes/recover/`.\nIf synchronization is blocked, process that structured state instead of improvising reset, stash, merge, rebase, force, or branch replacement.\nAfter synchronization, commit the follow-up on top and re-run `no-mistakes axi run --intent \"...\"` with the original user intent.\nThis preserves every prior gate-fix commit regardless of its configured subject.\n\nThe CI step deliberately keeps watching the PR after checks pass, so\n`axi run` returns `checks-passed` the moment checks are green (or a trusted\n`no_ci: true` declaration covers a zero-check repository) rather than\nblocking on the human merge. Never poll or re-run waiting for the merge yourself.\nNever treat \"no CI checks reported\" alone as green.\n\nBecause that monitor stays live, a PR that falls behind the default branch or\nhits a merge conflict after checks pass - commonly because another PR merged\nfirst - needs **no command from you**: never hand-rebase. When the CI monitor\nsees an actual conflict it **rebases onto the base, resolves it, and re-pushes\nthe branch itself**; a PR that is merely behind but still clean needs nothing\neither, since the platform merges it. The one exception is when that monitor is\nno longer running - the PR was closed, the run was aborted or superseded, it\nidle-timed-out, or its auto-fix attempts were exhausted - in which case recover\nwith `no-mistakes rerun`, which cancels the stale monitor and re-runs the full\npipeline including a deterministic rebase step. Do **not** reach for\n`no-mistakes axi run` to refresh a still-active PR: after `checks-passed` it\nreattaches to the running monitor (HEAD unchanged) and returns its output\nwithout rebasing.\n\nOn a successful outcome (`checks-passed` or `passed`), close the loop with the\nuser: summarize what happened during the pipeline in a concise, easily readable\nformat - what was validated and what was found. If the output includes a\n`fixes` table, the pipeline fixed findings your original change missed:\nacknowledge those misses and explicitly list each fix so the user can easily\nreview them.\n\n## Escalate `ask-user` findings\n\nA gate whose findings are all `auto-fix` or `no-op` is safe to drive on your\nown judgment: respond with `--action fix` or `--action approve` as\nappropriate. But a finding marked\n`ask-user` is a decision that belongs to the user, not you - the pipeline\nflagged it because it challenges their deliberate intent or changes product\nbehavior. Do not approve, fix, or skip it on your own. Instead, stop and bring\nit to the user before you respond:\n\n- Relay each `ask-user` finding to them as the pipeline wrote it - its\n `id`, `file`, and full `description` verbatim. Do not paraphrase,\n summarize away the detail, or pre-judge the answer.\n- Ask how they want to proceed, then translate their decision into the matching\n `respond` call: `--action fix` (pass their guidance through\n `--instructions`), `--action approve`, or `--action skip`.\n\nThe one exception is `--yes` (below): it is the user's standing consent to\ndrive every gate unattended, so under `--yes` you resolve `ask-user`\nfindings automatically instead of stopping to ask.\n\nIf you have clear consent to drive the run automatically, pass `--yes` to `axi run`\nor `axi respond`. It treats every actionable finding - `auto-fix` and\n`ask-user` alike - as consent to fix it, selects every current finding for one\nfix round, accepts the resulting fix review, and approves gates with only\n`no-op` findings. Only use it when the user has asked you to drive the whole\nrun without checking back.\n\n## Inspecting state\n\n```sh\nno-mistakes axi # home view: current branch, active runs, next steps\nno-mistakes axi status # full detail plus cached branch_sync when relevant\nno-mistakes axi sync --check # freshly verify an offered synchronization plan\nno-mistakes axi sync # apply only an offered guarded synchronization\nno-mistakes axi sync --recover # return custody after a terminal run left unpublished pipeline commits\nno-mistakes axi logs --step --full # full log output of one step\nno-mistakes axi abort # cancel the current-branch active run\nno-mistakes axi abort --run # cancel a specific run by id (works outside its worktree)\n```\n\n## Reading the output\n\n- Output is TOON: `key: value` pairs, `name[N]{cols}:` tables, and `help[N]:` hints.\n- A non-terminal run object may include `awaiting_agent: parked ` immediately after `status`; that means the run is parked at a gate awaiting your `axi respond`.\n- A run object with a `running` or `fixing` step may include an `active_steps` table. Use it to see the active duration, latest activity, native agent PID, and current execution or fix round.\n- The `help` list at the bottom of most responses tells you the next commands to run.\n- Errors are printed as `error: ...` on stdout with a `help` list; act on the suggestion.\n- Exit codes: `0` success, no-op, or normal decision gates, `1` failed or cancelled final outcomes, `2` bad usage.\n\nA `gate:` waiting on you looks roughly like this - a `gate:` line naming the step, optional step-specific fields such as `note`, a `findings[N]{...}:` table with one row per finding, and a `help[N]:` list of next commands:\n\n```\ngate: review\nnote: Review auto-fix is disabled by default (auto_fix.review: 0; a repo or global auto_fix.review > 0 override re-enables it), so blocking and ask-user review findings park for your decision rather than being silently self-fixed.\nfindings[2]{id,severity,file,line,action,description}:\n r1,warning,internal/pipeline/executor.go,,auto-fix,Error from os.Remove is ignored\n r2,error,cmd/no-mistakes/main.go,,ask-user,New --force flag bypasses the confirm prompt\nhelp[6]:\n Run `no-mistakes axi respond --action approve` to accept this step and continue\n Run `no-mistakes axi respond --action fix --findings ` to have the pipeline fix the selected findings (do not edit files yourself)\n Run `no-mistakes axi respond --action skip` to skip this step\n Run `no-mistakes axi logs --step review --full` to read the full step log\n A long-running call is working, not stalled - background it if your harness needs to, but the run never advances past a gate on its own. Read every return; on a `gate:`, respond; loop until an `outcome:`.\n Commit post-pipeline follow-up work on top of the existing branch so every pipeline fix commit remains present. Never abort-and-restart, reset, or replace the branch in a way that drops prior gate-fix commits.\n```\n\nRead the `action` column per row: decide `r1` (auto-fix) on your own\njudgment - `respond --action fix --findings r1` hands it to the pipeline to\nfix - but stop and escalate `r2` (ask-user) to the user before responding. A\nfinal state\ninstead shows `outcome: ` with no\n`findings` table. Field names and exact columns can vary by step and version,\nso read the actual `findings` header rather than assuming this layout.","skillMdTruncated","frontmatter",{"_248":7,"_38":41,"_44":45},"user-invocable","totalSizeBytes","runtime",{"_252":7,"_253":31,"_254":-5,"_255":31,"_256":31,"_257":31,"_258":259,"_260":261},"requiresBash","requiresMcp","model","requiresNode","requiresNetwork","requiresPython","allowedTools",[],"dependencies",[],"install",{"_264":265,"_266":267,"_268":269,"_270":271,"_272":273},"cli","npx skills add kunchenguid/no-mistakes/no-mistakes","coordinate","kunchenguid/no-mistakes/no-mistakes","browseUrl","https://github.com/kunchenguid/no-mistakes/tree/main/skills/no-mistakes","downloadUrl","https://github.com/kunchenguid/no-mistakes/archive/refs/heads/main.zip","gitUrl","https://github.com/kunchenguid/no-mistakes.git","createdAt","2026-08-11T01:31:43.315Z","updatedAt","2026-08-11T05:12:37.915Z","hasNext","page","actionData","errors"]