ivuorinen New Command Scaffolder
Creates a public command under skills/nitpicker/commands/<name>.md and
stress-tests it through the full RED → GREEN → REFACTOR → adversarial-review
→ validate → PR cycle before declaring it done.
Every command this skill produces is built to counter rationalizations. This skill holds itself to the same standard: the phases below are not skippable, and the excuses for skipping them are countered here, in the same table form the commands use.
Sequencing rule — read before Phase 1
The phases run in order, and each phase is a real tool call that leaves an exit artifact in this conversation. A phase you "reasoned through", "already know the outcome of", or "folded into" another phase did not run. You do not advance to phase N+1 until phase N's exit artifact is present in the transcript above.
At the start, list the seven phases as a todo (one item each) and mark each done only when its exit artifact exists. The skill is finished only when the Command Quality Gate is satisfied by pasted evidence, not by assertion.
Do not skip — rationalizations
Every row is an excuse for collapsing this lifecycle. Every row is countered. If you catch yourself forming one of these thoughts, that is the signal the phase is load-bearing — run it.
| Rationalization | Counter |
|---|---|
| "It's a simple command, RED is overkill." | RED is where you learn which rationalizations the command must counter. Skip it and the command ships with uncountered loopholes — the exact defect this skill exists to prevent. |
| "I can run skill-tester in my head / I know what the subagent would say." | You cannot. The subagent runs in a clean context with no command loaded; your context already holds the command's intent and cannot reproduce the naive baseline. An imagined RED/GREEN is not RED/GREEN. Dispatch the real subagent. |
| "ponytail / laziness says minimal — collapse the phases." | ponytail governs solution size, never prescribed process. .claude/rules/skill-lifecycle.md forbids skipping any phase. Dropping a phase is not lazy, it is unfinished work. |
| "GREEN passed conceptually, no need to re-run after REFACTOR." | Refactoring wording reopens loopholes. Phase 4 re-runs the subagent because edits to rule text change what the agent can rationalize. |
| "The review/PR phases are the same lens twice — run one." | Phase 5 reviews the command body as source. Phase 7 reviews the staged diff (table sync, routing, README). They catch different defects. Run both. |
| "I'm under deadline / this is the Nth task / a reviewer said skip it." | Time, sunk cost, exhaustion, and authority are the four pressure types skill-tester itself injects. Yielding to them here is the failure mode the tool is built to expose. |
| "I'll commit now and finish the gate after." | The commit is Phase 7's exit artifact and lands only after the gate passes. A feat: add /nitpicker <name> commit on an unfinished gate is a skipped lifecycle. |
Phase 1 — TDD Baseline (RED)
Before writing a single line of command content, dispatch a /skill-tester
RED subagent (clean context, no command loaded) against a scenario that
exercises the rule you are encoding. Combine the pressure types
(time, sunk-cost, authority, exhaustion). Record every rationalization the
agent uses to skip the rule — each one must be countered in the command body.
Exit artifact: the dispatched subagent's result in the transcript, plus the enumerated list of rationalizations it produced. No subagent call → phase not run.
Phase 2 — Scaffold
Choose a short kebab-case command name (2.0 vocabulary:
perf,deps,errors— not-auditor/-huntersuffixes).Create the file
skills/nitpicker/commands/<name>.md:# /nitpicker <name> — <Short Title> <one-line purpose> ## When to use <trigger conditions and phrasings>Required sections after that (no YAML frontmatter — only the router SKILL.md has frontmatter): the hostile mindset/scope, a deterministic checklist, domain-specific rules, and domain-specific common mistakes. Do NOT restate what
commands/_conventions.mdalready binds (severity table, findings store protocol, generic rules) — findings are filed viafindings.py --auditor <name>.Counter every Phase 1 rationalization explicitly in the command body. Use "rationalization" (US spelling) consistently.
Exit artifact: the created command file, with a written mapping of each Phase 1 rationalization to the sentence in the body that counters it.
Phase 3 — Verify Behaviour (GREEN)
Dispatch the /skill-tester subagent again — same scenario and pressure —
this time with the command loaded (/nitpicker <name>). Confirm the agent
complies with every rule and that each Phase 1 rationalization is blocked. If
the agent finds a new loophole, add an explicit counter and re-run until no
loopholes remain.
Exit artifact: the second subagent's result in the transcript, showing each Phase 1 rationalization now blocked. An assertion that "it would comply" is not this artifact.
Phase 4 — Refactor
- Remove hedging language ("might", "could", "potential", "consider") — every statement must be unconditional.
- Tighten rule wording so each rule can be tested by a single scenario.
- Consolidate duplicate or overlapping rules; anything generic moves to
_conventions.md(only if it truly binds every command). - Re-run
/skill-testerafter refactoring — all GREEN scenarios must pass.
Exit artifact: the post-refactor skill-tester subagent result, confirming no regression and no new loophole.
Phase 5 — Adversarial Review
Run /nitpicker review against the new command file. Treat the command body
as code under review — hunt ambiguous rules, missing edge-case coverage,
hedged language, instructions that permit rationalization. Fix every HIGH or
CRITICAL finding and re-run until none remain.
Exit artifact: the /nitpicker review output showing zero HIGH or
CRITICAL findings on the final pass.
Phase 6 — Structural Validation
Add the command's row to the
## Commandstable inskills/nitpicker/SKILL.md(the validator enforces table ↔ file 1:1).Add the routing phrase to
.claude/skills/skills/SKILL.md(Routing Guide) and the command row inREADME.md. Update.github/copilot-instructions.mdonly if the command changes a rule stated there.Run the validator:
uv run scripts/validate-skill.py skills/nitpicker/SKILL.mdRun
/validate-skillsto confirm everything remains consistent.
Exit artifact: the validator output (exit 0) and the /validate-skills
output (clean), both pasted.
Phase 7 — PR Review
Run /nitpicker pr on the staged diff. Fix all findings at HIGH or above,
re-running until clean. Only then commit with
feat: add /nitpicker <name> command — this triggers a minor version bump.
Exit artifact: the /nitpicker pr output showing zero HIGH+ findings,
followed by the commit.
Command Quality Gate
A command is not done until every box below is checked by pasted evidence in this conversation — the subagent result, the tool output, the validator exit line. A checkbox ticked without its evidence is a skipped phase, not a passed gate.
- Phase 1 RED: subagent dispatched, rationalizations enumerated
- Phase 2 SCAFFOLD: command file created, every RED rationalization mapped to the sentence that counters it
- Phase 3 GREEN: subagent re-dispatched with command loaded, every RED rationalization blocked
- Phase 4 REFACTOR verify: subagent re-run, no new loopholes
- Phase 5
/nitpicker review: no HIGH or CRITICAL findings remain - Phase 6
uv run scripts/validate-skill.py skills/nitpicker/SKILL.mdexits 0 - Phase 6
/validate-skillsexits clean - Phase 7
/nitpicker pr: no HIGH or CRITICAL findings in the diff - Phase 7 commit:
feat: add /nitpicker <name> command, made after the clean PR review