using-superpowers
/using-superpowers
Use when starting any conversation - establishes how to find and load relevant skills before responding, including clarifying questions
- Author
- ehartye ↗
- Repository
- hartye-superpowers ↗
- Licence
- MIT
- Last repository change
- 05.09.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 05.09.2026, without references to retired models or APIs.
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
- How to Access Skills
- The Core Rule
- Moments Where Missions Go Sideways
- Skill Priority
- Right-Sizing Process (default to action; gate only what you can't take back)
- Skill Types
- User Instructions
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
| Repository | Score | Licence |
|---|---|---|
| This page · ehartye/hartye-superpowers | 100 | MIT |
| coco-research/coco | 100 | MIT |
| osmontero/opencode-skills | 100 | MIT |
| seaworld008/commonly-used-high-value-skills | 100 | MIT |
| chinkan/RustFox | 100 | MIT |
| VoDaiLocz/kilo-kit-mcp | 100 | Apache-2.0 |
| sickn33/agentic-awesome-skills | 100 | MIT |
| liyunxuanyu/dsh-zcode-port | 100 | MIT |
| LiHongwei-cn/lihongwei-cn | 100 | MIT |
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