superpowers guru

• a distilled catalog keeps fourteen process skills findable from one page: trigger, procedure, failure prevented, hard rules — no re-reading the source repo.
• discipline must be discoverable, not remembered: an agent under pressure locates the applicable skill instead of rationalizing a skip.
• superpowers is a discipline system for agent-assisted development: process skills that gate creative work behind design approval, implementation behind tests and plans, and completion claims behind fresh evidence.
• distillation lets local corpus owners supersede upstream guidance (worktrees, testing) in one visible place.

• using superpowers — check for a skill before any response or action.
• brainstorming — ideas become approved designs before code exists; the approval gate never scales down.
• writing plans — specs become bite-sized tasks with complete code and interfaces, written for zero-context executors.
• executing plans — follow the plan exactly, verify every step, stop when blocked.
• subagent-driven development — fresh subagent per task, review gates between tasks, a ledger that survives compaction.
• test-driven development — no production code without a failing test first; the rationalizations, named and countered.
• systematic debugging — root cause before any fix; three failed fixes means question the architecture.
• verification before completion — no completion claims without fresh evidence.
• requesting code review — dispatch fresh reviewers with crafted context at every gate.
• receiving code review — evaluate technically, push back when wrong, never perform agreement.
• dispatching parallel agents — one agent per independent domain, prompts that keep them focused.
• worktree guidance superseded — upstream source retained for provenance; local policy forbids worktrees.
• finishing a development branch — verify, then present exactly three options; integration is the partner's decision.
• writing skills — TDD applied to documentation: baseline the failure, counter the rationalizations, close every loophole.

every skill attacks the same enemy: rationalized skipping under pressure. forms vary — iron laws, rationalization tables, red-flag lists, approval gates, ledgers — but each makes a discipline visible at the moment it's about to be abandoned.

where this distillation meets an owner decision, curly standards hold the local rule:

• TDD meets the no-tests decision — verification without tests.
• worktree guidance is superseded — no git worktrees.
• the skill system's local operating contract — superpowers.

bad

agent guidance: remember the testing discipline and the design approval gate
result under pressure: skips test when features "seem simple," skips approval
  when "the change is obviously right," skips review when "code is clean"
each skip feels justified in isolation; together they compound.
outcome: untested feature breaks a related system; unreviewed design
  conflicts with the architecture; unreviewable change introduces a bug
recovery: investigation and fixes; re-testing and re-review at double cost

implicit discipline disappears under pressure: no triggers, no observable boundary, no recorded exceptions — every skip looks like judgment while compounding into untested, unreviewed work. recovery costs multiples of the original effort.

good

skill catalog: explicit trigger ("before editing code"), procedure ("read the
  heading, stop if do-not-edit"), failure modes named ("rationalization: 'I'll
  fix it later'"), verification ("are we still following the gate?")
result under pressure: the written trigger remains visible; exceptions become
  explicit decisions, not rationalized skips; the ledger records each one
outcome: discipline survives pressure because it's discoverable, not remembered

explicit skills are discoverable, repeatable, auditable — they survive time pressure; implicit rules are the first casualty.