agentleFS
VladTheProgrammerVladTheProgrammer/claude-asimov/.claude/skills/review-auto/SKILL.md

review-auto

Skill0 starsChanged 4 months agoMITView on GitHub

Autonomous (non-interactive) post-execute review for the autopilot. After execute-auto lands a task, an independent adversarial reviewer reads the task's DIFF and gates on confirmed correctness/cross-module/safety findings before the task is "done". Invoked by /autopilot; never run interactively.

The file

We split this skill into the rules it gives an agent

6 rules. About 0 are common, 3 are distinctive, and 3 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈3

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 3

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Default to the core review.

    line 18
  2. Distinctive:

    + live-smoke: only if the diff changes a path with real-world side effects — a write to an external system, an outbound request, or the …

    line 21
  3. Very specific:

    + security pass (/security-review): only if the diff touches credentials, authorization, or anything that spends money or sends data …

    line 24
  4. Distinctive:

    Bound it: verify at most the top ~8 highest-risk findings, at most 2 fix-loops.

    line 28
  5. Very specific:

    Gate: only a confirmed safety/correctness finding blocks → attempt a bounded fix (<=2 tries) via the execute path.

    line 57
  6. Very specific:

    Run scripts/fitness.sh as part of the review — it runs the import-linter architecture contracts, arch_graph.py --check (dependency-graph …

    line 67

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

You are running review in autonomous mode for the autopilot — no human to talk to. A task's execute just finished; you are the independent second pair of eyes the author could not be for itself. Review the task's diff, gate on confirmed bugs, and either fix (bounded) or escalate.

Inputs (read first)

  • The task's diff — git diff of the task's commits (the actual landed change). This is the subject.
  • docs/{task}/{research,design,structure,plan,execute}.md — intent + the blast-radius map research produced (the cross-module checklist you verify against).
  • docs/objective.md, the wiki (wiki/decisions/ = ratified authority), CLAUDE.md + .claude/rules/ (the invariants), and .claude/skills/code-review/ + /security-review for the base review flow.

Tier the rigor (do this first — don't tax trivial work, and stay bounded)

Default to the core review; add the expensive dimensions only on a specific trigger, not just because code is "important-ish" (most of a real system is — heavy-by-default would crawl the loop):

  • Core (always): correctness + cross-module consistency.
  • + live-smoke: only if the diff changes a path with real-world side effects — a write to an external system, an outbound request, or the reconcile logic between them (not pure computation, logging, or config).
  • + security pass (/security-review): only if the diff touches credentials, authorization, or anything that spends money or sends data outward.
  • Light (correctness + cross-module, quickly): docs, infra, observability, tests-only.

Bound it: verify at most the top ~8 highest-risk findings, at most 2 fix-loops. A review must never spawn unbounded agents or exhaustively re-verify a huge diff — sample the highest-risk hunks.

Review dimensions — fresh adversarial agents, one per lens, prompted to FIND bugs

Effort pin: spawn every adversarial agent here — the per-lens finders below AND the refute agents in "Adversarial verification + gate" — with model: fable, effort: max (pinned, NOT inheriting the session). The autopilot session runs Opus 5 at high for cost, but the final safety review runs the strongest available model (Fable 5) at max effort — it is the gate that catches the subtle, near-money bugs.

  1. Correctness — logic errors, edge cases, error handling, off-by-one, and drift from design/structure/plan (did execute build what was specified?).
  2. Cross-module consistency — walk the research blast-radius map: is every consumer / dependent / caller / serializer / UI / doc / test of the changed code updated? The classic miss is "changed the logic, left the UI/serializer stale." Flag any consumer left behind.
  3. Offline ≠ live — is any side-effecting path exercised only offline (fakes/mocks)? If so flag "live behaviour unverified"; if the change is in the live-smoke trigger set above, require a minimal staging smoke before done (else just record the gap). Offline-green does not mean live-correct. High-severity heuristic: a request re-issued rather than amended on a recurring path (every cycle) is likely-blocking, not edge-case — it accumulates duplicate state in the external system, and any dedup key that varies between cycles will not save you. Block it, or at minimum raise it as a loud must-verify-on-soak item — never a quiet non-blocking note.
  4. Safety invariants (heavy tier) — explicitly verify the project's CLAUDE.md "Will Not Catch in Review" rules: the agent's credentials never carry more authority than the task needs; irreversible operations stay staging-only, never production autonomously; no circumvention of a control that exists on purpose. Run /security-review on any change touching credentials or authorization.

Adversarial verification + gate

  • Verify every finding with a risk-weighted bias (do NOT use one bias for all — that's the trap):
    • Safety / correctness findings → a second agent tries to refute, but default to escalate if uncertain. Near live money a missed bug is the expensive error — err toward over-flagging.
    • Style / quality / nit findings → default to refuted (don't chase non-bugs or review churn).
  • Gate: only a confirmed safety/correctness finding blocks → attempt a bounded fix (<=2 tries) via the execute path; if still unresolved → STOP and write docs/{task}/ESCALATE.md. For non-blocking findings, prefer fixing over filing: if a finding is trivial, in-scope, and gate-verifiable (a stale docstring/label, a missing honest-n/a, a one-line consumer/serializer update), fix it in a bounded follow-up commit through the gate rather than deferring — don't let easy wins pile up as low-value DEBT. File a DEBT: ticket only when the non-blocking item genuinely needs its own task (a design decision, correctness-critical logic, its own restart, or non-trivial scope); a pure style nit with no real value is recorded in review.md only (no DEBT, no escalation, no ping — review never recreates review-fatigue). Stay bounded — the same <=2 fix-loops / top-8 cap; review is not an open-ended cleanup pass. Never weaken a check or the diff to pass.
  • The task is not done until review is green (no unresolved confirmed safety/correctness finding).

Output

  • docs/{task}/review.md — per dimension: findings, the refute verdict, what was fixed, the residual non-blocking notes. Capture a one-line outcome to the wiki. Leave the tree at a clean boundary.

Fitness-function gate (stewardship)

Run scripts/fitness.sh as part of the review — it runs the import-linter architecture contracts, arch_graph.py --check (dependency-graph doc freshness + every subpackage governed), and the design checks. A broken contract is a blocking finding (architecture drift, not a nit): the task is not done until fitness is green.

You may not suppress, relax, or remove a contract to make your own task pass. Moving an enforced boundary is a human-ratified change above the autopilot's authority — open a needs-human Linear issue + touch .autopilot/paused; do not edit pyproject [tool.importlinter] or a wiki/architecture/ invariant autonomously. The autopilot is policed by the contracts; it does not get to rewrite them. (fitness.sh only enforces the import graph + doc freshness — seam-bypass and misplaced logic are still your job to catch by reading.)

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.