Agent skill

using-superpowers

Guidelines for using skills effectively - load relevant skills before complex tasks, not every message

Stars 3
Forks 1

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:

  1. Load it with the Skill tool
  2. Announce briefly: "Using [skill] for [purpose]"
  3. If it has a checklist, create todos
  4. 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:

  1. Process skills first (brainstorming, debugging) - these determine HOW to approach
  2. 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

Expand your agent's capabilities with these related and highly-rated skills.

Cygnusfear/claude-stuff

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.

3 1
Explore
Cygnusfear/claude-stuff

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.

3 1
Explore
Cygnusfear/claude-stuff

test-driven-development

Use when implementing any feature or bugfix, before writing implementation code

3 1
Explore
Cygnusfear/claude-stuff

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.

3 1
Explore
Cygnusfear/claude-stuff

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.

3 1
Explore
Cygnusfear/claude-stuff

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.

3 1
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results