Skip to content
OpenAgentSkill
Browsing is open · Catalog captured 2026-11-21 · Automatic updates and account services are paused.
Security

audit-and-fix

Audit an existing codebase, then autonomously implement the fixes it judges worth making against your next goal — composing deep-dive → triage → prompt-pack → build-loop to turn "here's what's wrong" into verified, receipted local commits + an honest ledger. ALWAYS invoke when the user says any of "audit this repo and fix what you find", "audit and edit", "deep dive then fix the bugs", "implement the audit's recommendations", "plan and execute these fixes", or "autopilot this repo but skip the ideation". It composes those skills, never reimplementing them. Honest bounds: a receipt records what ran, it never proves correctness; the deep-dive→triage→pack half is proven, the build-loop seam is not; local commits only, never push/merge/tag/publish. Do NOT use to audit with no intent to change (deep-dive), for a change you already know you want (prompt-pack + build-loop), for a new idea with no codebase (autopilot), or for feature work — it fixes what the audit found, nothing more.

nelsonwerd · AI review on file

Installation

Read the source and dependencies before running a command. Copying does not install or execute anything.

npx skills add nelsonwerd/idea-to-ship-skills --skill audit-and-fix

About this skill


name: audit-and-fix description: >- Audit an existing codebase, then autonomously implement the fixes it judges worth making against your next goal — composing deep-dive → triage → prompt-pack → build-loop to turn "here's what's wrong" into verified, receipted local commits + an honest ledger. ALWAYS invoke when the user says any of "audit this repo and fix what you find", "audit and edit", "deep dive then fix the bugs", "implement the audit's recommendations", "plan and execute these fixes", or "autopilot this repo but skip the ideation". It composes those skills, never reimplementing them. Honest bounds: a receipt records what ran, it never proves correctness; the deep-dive→triage→pack half is proven, the build-loop seam is not; local commits only, never push/merge/tag/publish. Do NOT use to audit with no intent to change (deep-dive), for a change you already know you want (prompt-pack + build-loop), for a new idea with no codebase (autopilot), or for feature work — it fixes what the audit found, nothing more.

Audit-and-Fix — autonomous audit→fix orchestrator

audit-and-fix points at an existing repo, runs a rigorous read-only audit, makes a value judgment about what's worth fixing, takes one human go, then autonomously sequences and implements the triaged fixes — receipted, unit by unit, one commit per verified boundary — and stops at local commits.

It is an orchestrator: it composes the existing skills and never reimplements them. It invokes deep-dive, prompt-pack, and build-loop, carries each one's file output into the next, and adds only the connective tissue — the triage verdict, the single gate, the regression fence, the receipt discipline, the resume contract, and the honest ledger. If a phase tempts you to paste a sub-skill's procedure into this run, stop: invoke the skill instead.

It is autopilot pointed backwards. autopilot builds something that doesn't exist and risks inventing demand; audit-and-fix repairs something that does and risks breaking working software. Dropping ideate isn't a shortcut — the codebase replaces it as the source of truth. There is nothing to invent, so there's no grounding firewall to hold; the analogous rule here is a green test is not a fixed bug, and a non-reproduction is not a fix.

When to use this

Strong triggers — invoke without asking:

  • "Audit this repo and fix what you find" / "deep dive then fix the bugs" / "audit and edit"
  • "Implement the audit's recommendations"
  • "Autopilot this repo, but skip the ideation"
  • "Plan and execute these fixes" — said after a deep-dive briefing already landed. That's this skill, entering at Phase 3 (and see the gate table: the findings were read, so no gate — within the bound).

Do NOT use this for:

  • Auditing with no intent to change — that's deep-dive, and it's cheaper.
  • A change you already know you want — that's prompt-pack (+ build-loop). Nothing to discover.
  • A new idea / greenfield — that's autopilot. There's no codebase to be the grounding.
  • Feature work. It fixes what the audit found. It does not add features. (This is the fence, not modesty.)
  • A non-git repo. git init first — this isn't a receipt technicality: the baseline SHA, the fence proof, the commit-per-unit cadence, and resume are all defined in terms of git. Without it there is no run, not a degraded one.
  • A repo with no verification surface (docs/prose) — nothing to receipt, so nothing to prove.

Routing tie-breaker: deep-dive answers "is it sound?" and stops. audit-and-fix answers "is it sound, what's worth fixing given where you're headed — now go fix it, receipted, and stop before you publish." If the user shows no intent to change the code, it's deep-dive.

What it produces — and its honest bounds (read this before you trust it)

Load-bearing, stated up front so no one reads an autonomous fix run as more than it is.

Produces: a read-only evidence package, a triage verdict, a durable fix pack, a sequence of verified local commits with receipts, and an honest ledger of what's checked vs. what only a human can clear.

The 6 eyes-open limits it does NOT escape:

  1. A receipt records; it does not prove. tree-exact means recorded against the sealed tree — never proven correct. What's proven is that the recorded commands passed on that tree. Never translate a grade upward.
  2. It fixes what the audit found. Absence of findings ≠ absence of bugs. deep-dive's confidence is capped by its ground-truth tally, and its fan-out is the same model — it surfaces where independent reasoning diverges, never an error every lane shares. Report that cap verbatim; never launder a judgment call into a fact.
  3. The live/real-world tail is never cleared. Real accounts, real money, real users, real production, the first CI run. The fixes make the evidence trustworthy — they do not clear the gate. Those human labels correctly stay.
  4. Local commits only. Push, merge, tag, publish, spend — the human's, every time, per-action, per-session.
  5. It is expensive and it will hit limits. Millions of tokens; hours. Expect to resume.
  6. Half of this composition is unproven. The deep-dive → triage → pack half has run for real, repeatedly — though "it ran" is not "it was right" (see the triage note below). The build-loop-per-unit seam has never actually run: the runs this skill distills hand-rolled that discipline and never invoked the skill. The seam is clean on paper and untested in fact — expect it to need real use before you trust it. Don't read the gap as a virtue.

The triage is a judgment, not a measurement. It is the highest-authority call in the run — it produces the scope — and it has never once been vetoed, which is not evidence it was right: an un-vetoed triage and an unchecked triage look ident

Read the complete source ↗