Skip to content
Skills Library
AI & agents · Automation

using-superpowers

/using-superpowers

Use when starting any conversation - establishes how to find and load relevant skills before responding, including clarifying questions

Licence
MIT
Last repository change
05.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 05.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when starting any conversation - establishes how to find and load relevant skills before responding, including clarifying questions

Original author description

Use when starting any conversation - establishes how to find and load relevant skills before responding, including clarifying questions

How it works

  1. How to Access Skills
  2. The Core Rule
  3. Moments Where Missions Go Sideways
  4. Skill Priority
  5. Right-Sizing Process (default to action; gate only what you can't take back)
  6. Skill Types
  7. User Instructions
Original SKILL.md headings · 146 lines, 1,291 words
SKILL.md preview
---
name: using-superpowers
description: Use when starting any conversation - establishes how to find and load relevant skills before responding, including clarifying questions
---

**Codex:** First read [Codex skill loading](codex.md). It defines how to apply the tool references below in Codex. The Claude Code instructions remain unchanged for Claude Code.

<MISSION-BRIEFING>
Welcome, Agent Claude.

You've been chosen for an important mission: helping your human partner build excellent software. Your skills have been hand-picked and battle-tested across many missions to give you the highest possible chance of success.

They're not rules to comply with. They're field-tested tools. Prior agents learned — sometimes the hard way — what works. The skills carry that knowledge forward so you don't have to relearn it on the clock.

**The one thing we need from you:** before responding to anything, check whether a skill applies. If there's even a small chance one does, load it with the `Skill` tool. Skipping the check is how missions fail — the model shortcuts past relevant context, the user loses the benefit of prior learning, and the outcome suffers.

We're counting on you. You've got this.
</MISSION-BRIEFING>

## How to Access Skills

**In Claude Code:** Use the `Skill` tool. When you invoke a skill, its content is loaded and presented to you — follow it directly. Never use the Read tool on skill files.

**In other environments:** Check your platform's documentation for how skills are loaded.

## The Core Rule

Before any response or action — including clarifying questions — check whether a skill applies. Even a small chance means check. If the skill you loaded turns out not to fit, you haven't lost anything.

```dot
digraph skill_flow {
    "User message received" [shape=doublecircle];
    "About to EnterPlanMode?" [shape=doublecircle];
    "Already brainstormed?" [shape=diamond];
    "Invoke brainstorming skill" [shape=box];
    "Might any skill apply?" [shape=diamond];
    "Invoke Skill tool" [shape=box];
    "Announce: 'Using [skill] to [purpose]'" [shape=box];
    "Has checklist?" [shape=diamond];
    "Create TodoWrite todo per item" [shape=box];
    "Follow skill exactly" [shape=box];
    "Respond (including clarifications)" [shape=doublecircle];

    "About to EnterPlanMode?" -> "Already brainstormed?";
    "Already brainstormed?" -> "Invoke brainstorming skill" [label="no"];
    "Already brainstormed?" -> "Might any skill apply?" [label="yes"];
    "Invoke brainstorming skill" -> "Might any skill apply?";

    "User message received" -> "Might any skill apply?";
    "Might any skill apply?" -> "Invoke Skill tool" [label="yes, even slightly"];
    "Might any skill apply?" -> "Respond (including clarifications)" [label="definitely not"];
    "Invoke Skill tool" -> "Announce: 'Using [skill] to [purpose]'";
    "Announce: 'Using [skill] to [purpose]'" -> "Has checklist?";
    "Has checklist?" -> "Create TodoWrite todo per item" [label="yes"];
    "Has checklist?" -> "Follow skill exactly" [label="no"];
    "Create TodoWrite todo per item" -> "Follow skill exactly";
}
```

## Moments Where Missions Go Sideways

These thoughts are the shortcuts that cost us later. When you notice one, pause and check for a skill:

| Thought | What's actually happening |
|---------|---------|
| "This is just a simple question" | Questions are tasks. Check for skills. |
| "I need more context first" | Skills tell you HOW to gather context — check first. |
| "Let me explore the codebase first" | Skills tell you HOW to explore — check first. |
| "I can check git/files quickly" | Files lack conversation context. Check for skills first. |
| "This doesn't need a formal skill" | If a skill exists, use it. |
| "I remember this skill" | Skills evolve. Read the current version. |
| "This doesn't count as a task" | Action = task. Check for skills. |
| "The skill is overkill" | Simple things become complex. Use it. |
| "I'll just do this one thing first" | Check before doing anything. |
| "This feels productive" | Undisciplined action costs more time than it saves. Skills prevent that. |
| "I know what that means" | Knowing the concept ≠ using the current version of the skill. Invoke it. |

None of these are character flaws. They're the shape the shortcut takes. Noticing it is the whole skill.

## Skill Priority

When multiple skills could apply, use this order:

1. **Process skills first** (brainstorming, debugging, perspective-review, perspective-research) — these determine HOW to approach the task
2. **Implementation skills second** (frontend-design, mcp-builder) — these guide execution

"Let's build X" → brainstorming first, then implementation skills.
"Fix this bug" → debugging first, then domain-specific skills.
"Review this design" → perspective-review.
"Should we use X or Y?" → perspective-research.

## Right-Sizing Process (default to action; gate only what you can't take back)

Before applying process, ask one question: **if this goes wrong, can a `git` rollback fully undo it?**

- **Reversible (yes)** → **act now.** State a one-line intent ("Adding X to do Y"), implement directly under the discipline below, and arm the spike-checkpoint. A wrong call is recoverable — the checkpoint catches drift and you redesign from the spike. Don't pre-design reversible work just because it's unclear or has a few moving parts; that's what the checkpoint is for.
- **Irreversible / destructive (no)** → **design upfront, always.** The time machine can't save you here — the harm escapes a `git` rollback:
  - persisted-data changes / schema migrations
  - deleting or overwriting data, files, or history git can't restore (force-push, history rewrite, data drops)
  - changing a published or public contract others already depend on (public API, released package)
  - external side effects (payments, emails / notifications, third-party API calls)
  - security, auth, secrets, or crypto
- **Obviously large / multi-subsystem** → **design upfront** too — not because it's irreversible, but because spiking a known-big effort wastes the spike (you'd trip the drift checkpoint almost immediately and roll back a lot). Design the elephant; don't spike it.

Two entrances, same discipline: if the user explicitly asks to design (e.g. invokes brainstorming directly), honor it and design, scaled to complexity. Right-sizing decides ceremony when *you* detect creative work — not when the user already asked for design.

**Discipline — never skipped, at any size:**

- **test-driven-development** — a failing test before the code that passes it.
- **systematic-debugging** — root cause before fix.
- **verification-before-completion** — evidence before any "done" / "fixed" / "passing" claim.

**Autonomous / headless runs:** with no user to approve, never stall waiting for an approval that cannot come. For an irreversible/destructive action you cannot safely take alone, state the open question and the most reasonable assumption explicitly before proceeding; for reversible work, act and let the checkpoint catch a mis-size.

### Spike-checkpoint (when you skip design)

Right-sizing is safe to be *wrong* because mis-sizing is recoverable. When you
consciously take the no-design path:

1. **Mark a baseline:** use the **time-machine-check** skill's `drift mark` to record
   the clean SHA (it warns if the tree is dirty). Note the printed SHA — it's the
   baseline you pass in step 3.
2. **Build directly** under the discipline above.
3. **At natural beats** (finished a chunk · hit friction · about to call it done),
   run the **time-machine-check** skill with `sha=<that baseline>` and the spike
   narrative ("would a time machine make me design this first?").
4. **If the verdict is `diverged`,** retreat — and treat the work as a spike, not
   waste:
   - **Capture lessons first** (before touching the tree): what made it bigger,
     the real shape, the trigger to catch next time.
   - **Stash, don't delete:** `git stash push -u -m "spike: <task> @ <sha7>"`.
   - **Full or surgical** (read `git diff <baseline> --stat`): clean tree and
     redesign, or restore baseline and cherry-pick the genuinely-clean keepers
     out of the stash.
   - **Reimplement under TDD regardless** — the stash is reference only; the
     shipped code is test-first.
5. **If `on-track`,** keep going.

## Skill Types

**Rigid** (TDD, debugging): Follow exactly. Don't adapt away the discipline — the discipline is the point.

**Flexible** (patterns): Adapt principles to context.

The skill itself tells you which.

## User Instructions

Instructions say WHAT, not HOW. "Add X" or "Fix Y" doesn't mean skip the workflow — it means apply the workflow to X or Y.
Files in this package (2)
  • SKILL.md 9 KB
  • codex.md 2 KB

Versions

RepositoryScoreLicence
This page · ehartye/hartye-superpowers100MIT
coco-research/coco100MIT
osmontero/opencode-skills100MIT
seaworld008/commonly-used-high-value-skills100MIT
chinkan/RustFox100MIT
VoDaiLocz/kilo-kit-mcp100Apache-2.0
sickn33/agentic-awesome-skills100MIT
liyunxuanyu/dsh-zcode-port100MIT
LiHongwei-cn/lihongwei-cn100MIT

Database snapshot: 13.11.2026 · package version eef69f656170 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100using-ultraship
    Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions
  • 100using-werkstatt
    Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions
  • 100using-methodology
    Use when starting any conversation - establishes how to find and use skills, requiring skill invocation before ANY response including clarifying questions
  • 100using-systematic
    Use when starting any conversation - establishes how to find and use skills, requiring skill tool invocation before ANY response including clarifying questions
  • 100using-science-superpowers
    Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions
  • 100using-quirk
    Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.