Agent skill
using-superpowers
Guidelines for using skills effectively - load relevant skills before complex tasks, not every message
Install this agent skill to your Project
npx add-skill https://github.com/Cygnusfear/claude-stuff/tree/main/skills/using-superpowers
SKILL.md
Using Skills
Skills are specialized workflows that improve quality for specific task types. Use them when they apply - don't skip them by rationalizing, but also don't invoke them ritualistically.
When to Load a Skill
DO load skills when:
- Starting a complex or multi-step task
- The task clearly matches a skill's description (code review, debugging, planning, etc.)
- You're unsure how to approach something and a skill might help
- The user explicitly requests a skill-based workflow
DON'T load skills when:
- Answering simple questions or having conversation
- Doing trivial file reads or small edits
- The task is straightforward and no skill adds value
- You already know the skill's content from this session
How to Use Skills
When a skill applies:
- Load it with the Skill tool
- Announce briefly: "Using [skill] for [purpose]"
- If it has a checklist, create todos
- Follow the skill's workflow
Avoiding Common Mistakes
Under-using skills (rationalizing):
| Thought | Consider |
|---|---|
| "I'll just do this quickly" | Would a skill improve quality? |
| "This doesn't need a formal process" | Is there a skill that applies? |
| "I remember how this works" | Skills evolve - reload if unsure |
| "Let me explore first" | Some skills guide exploration |
Over-using skills (ritual compliance):
| Thought | Reality |
|---|---|
| "I must invoke skills on every message" | Only when they add value |
| "Let me check for mandatory skills" | Skills aren't rituals |
| "Confirming skill protocol compliance" | Just do the work |
Skill Priority
When multiple skills could apply:
- Process skills first (brainstorming, debugging) - these determine HOW to approach
- Implementation skills second - these guide execution
Examples:
- "Let's build X" → brainstorming first, then implementation
- "Fix this bug" → debugging first, then domain-specific skills
Skill Types
Rigid (TDD, debugging): Follow the process exactly.
Flexible (patterns): Adapt principles to context.
The skill itself indicates which type it is.
Remember
- Skills improve quality for complex tasks
- Simple tasks don't need skill overhead
- If you're announcing "checking mandatory protocols" you've gone too far
- Just use skills naturally when they help
Recommended Agent Skills
Expand your agent's capabilities with these related and highly-rated skills.
brainstorming
You MUST use this, UNLESS the human says otherwise, before any EXTENDED creative work (not simple execution) - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.
axiom-audit
ONLY USE WHEN REPO IS USING AXIOM LOGGING. Audit Axiom logs to identify and prioritize errors and warnings, research probable causes, and flag log smells. Use when user asks to check Axiom logs, analyze production errors, investigate log issues, or audit logging patterns.
test-driven-development
Use when implementing any feature or bugfix, before writing implementation code
create-plan
Create comprehensive implementation plan in .plans directory based on analysis or report. Use when user asks to create a plan, plan implementation, design a solution, or structure work for a feature/refactor/fix.
video-explorer
This skill should be used when analyzing video files. Claude cannot process video directly, so this skill extracts frames hierarchically - starting with a quick overview, then zooming into regions of interest with higher resolution and temporal density. Use when asked to watch, analyze, review, or understand video content.
the-archivist
This skill should be used when engineering decisions are being made during code implementation. The Archivist enforces decision documentation as a standard practice, ensuring every engineering choice includes rationale and integrates with Architecture Decision Records (ADRs). Use when writing code that involves choosing between alternatives, selecting technologies, designing architectures, or making trade-offs.
Didn't find tool you were looking for?