←Back to Skill Directory

Skills Pack

Superpowers Skills for Claude Code

The Superpowers skills pack is a structured library of pre-built workflow skills for Claude Code. Each skill is a markdown instruction file that shapes how Claude reasons, enforces process discipline, and applies consistent judgment across software projects—without relying on the model's default behavior or prompt engineering from scratch.

Skills in this pack cover the full development lifecycle: planning and brainstorming before coding, test-driven development during implementation, systematic debugging when things break, and structured code review and verification before shipping. The pack also includes orchestration skills for parallel agent work and git workflow management.

View on GitHubInstall Guide ↓

Quick install — Claude Code CLI

claude plugin install superpowers

Or copy the skill files into your project's .agent/skills/ directory and reference them in CLAUDE.md.

Process Skills

3 skills

Implementation Skills

3 skills

Review Skills

3 skills

Orchestration Skills

3 skills

Skill Directory

Superpowers Skills by Category

Skills are organized into four categories based on when in the development lifecycle they apply. Invoke the right skill before starting each phase rather than relying on Claude's default behavior.

Process Skills

brainstorming

Explores user intent and design before writing any code. Must be used before creative or feature work.

systematic-debugging

Structured root-cause analysis before proposing fixes. Prevents symptom-chasing.

verification-before-completion

Requires running verification commands and confirming output before claiming any task is done.

Implementation Skills

test-driven-development

Write tests first, then minimal implementation code to pass them. Enforces 80%+ coverage.

writing-plans

Creates step-by-step implementation plans with risk assessment before touching code.

executing-plans

Executes written plans with review checkpoints in separate sessions.

Review Skills

requesting-code-review

Triggers a structured review after completing major features or before merging.

receiving-code-review

Applies technical rigor when receiving feedback—verifies before implementing suggestions.

finishing-a-development-branch

Guides completion with structured options for merge, PR creation, or cleanup.

Orchestration Skills

dispatching-parallel-agents

Launches 2+ independent tasks as parallel subagents to maximize throughput.

subagent-driven-development

Executes plans with independent tasks delegated to subagents in the current session.

using-git-worktrees

Creates isolated git worktrees for feature work that needs clean separation from main workspace.

Installation

How to Install Superpowers Skills in Claude Code

1

Add skills to project

Place skill files in your project's .agent/skills/ directory or a global skill location. Each skill is a .md file with YAML frontmatter and workflow instructions.

2

Reference in CLAUDE.md (optional)

Add a skills directory reference in CLAUDE.md so Claude Code knows where to find skills automatically. This enables the using-superpowers rule without manual loading each session.

3

Invoke via Skill tool

In Claude Code, use the Skill tool with the skill name to load and execute a skill. The skill content is loaded into context and followed directly for that task.

4

Verify invocation behavior

The using-superpowers skill enforces that any matching skill is invoked before responding. If you see Claude skipping known skills, check that the skill path is visible and the CLAUDE.md reference is correct.

Skill file frontmatter format

---
name: brainstorming
description: Use before creative or feature work to explore requirements and design
type: process
---

# Skill content goes here
## When to invoke
## Workflow steps
## Output format

Core Rule

The Skill Invocation Rule

The Superpowers system enforces one central rule: if there is even a 1% chance a skill applies to the current task, it must be invoked before any response or code. This rule prevents the most common failure mode in AI-assisted development—where the model skips structured workflow disciplines because the task “seems simple.”

Thought patternReality
“This is just a simple question”Questions are tasks. Check for skills.
“I need more context first”Skill check comes BEFORE clarifying questions.
“Let me explore the codebase first”Skills tell you HOW to explore.
“This skill is overkill for this task”Simple things become complex. Use it.
“I remember this skill from before”Skills evolve. Read the current version.

Execution Brief

Use this page as a rollout checklist, not just reference text.

Suggest update

Tool Mapping Lens

Organize Tools by Workflow Phase

Catalog-oriented pages work best when users can map discovery, evaluation, and rollout in a clear path instead of reading an undifferentiated list.

  • Define the job-to-be-done first
  • Group tools by stage
  • Prioritize by adoption friction

Actionable Utility Module

Skill Implementation Board

Use this board for Superpowers Skills for Claude Code before rollout. Capture inputs, apply one decision rule, execute the checklist, and log outcome.

Input: Objective

Deliver one measurable improvement with superpowers skills

Input: Baseline Window

20-30 minutes

Input: Fallback Window

8-12 minutes

Decision TriggerActionExpected Output
Input: one workflow objective and release owner are definedRun preview execution with fixed acceptance criteria.Go or hold decision backed by repeatable evidence.
Input: output quality below baseline or retries increaseLimit scope, isolate root issue, and rerun controlled test.One confirmed correction path before wider rollout.
Input: checks pass for two consecutive replay windowsPromote to broader traffic with fallback path active.Stable rollout with low operational surprise.

Execution Steps

  1. Record objective, owner, and stop condition.
  2. Execute one controlled preview run.
  3. Measure quality, latency, and correction burden.
  4. Promote only when pass criteria are stable.

Output Template

tool=superpowers skills
objective=
preview_result=pass|fail
primary_metric=
next_step=rollout|patch|hold
Share execution feedback

What Is Superpowers Skills for Claude Code?

Superpowers skills are structured workflow instruction files that extend Claude Code with named, repeatable process disciplines. Rather than relying on the model's default behavior for each task, a skill encodes a proven workflow—brainstorming before building, writing tests before implementation, running verification before claiming completion—and makes it invocable by name inside any Claude Code session.

The pack's value is not in the individual files but in the enforcement layer. The using-superpowers meta-skill imposes a rule that any task matching a known skill must invoke that skill before the model responds. This means process shortcuts do not happen silently. If brainstorming exists and a new feature is being planned, brainstorming runs. If systematic-debugging exists and a bug is encountered, the debugging skill structures the investigation before proposing a fix.

For teams building with Claude Code at scale, skills convert individual engineering discipline into a shareable team standard. A skill file represents a tested workflow that any team member can invoke consistently. That makes Superpowers skills one of the highest-leverage extensions you can add to a Claude Code setup: they do not add tools, they enforce quality.

How to Calculate Better Results with superpowers skills

Start with the four highest-impact skills: brainstorming for planning, test-driven-development for implementation, systematic-debugging for bug fixes, and verification-before-completion before closing any task. These four cover the most common failure modes in AI-assisted development and together form a minimum viable discipline layer for daily work.

Install the skills by placing the markdown files in your project's .agent/skills/ directory. Reference that path in CLAUDE.md so Claude Code discovers the skills automatically on session start. For global use across projects, install skills in the user-level Claude Code skill directory and Claude can access them from any project without per-repo setup.

Once installed, the enforcement rule matters more than the file content. Insist that skills are invoked before work, not after. A brainstorming skill run after writing code provides no value—it must run before. A verification skill used after announcing completion is too late—it must run before the claim is made. The Superpowers system is only effective when the ordering discipline is maintained.

Treat this page as a decision map. Build a shortlist fast, then run a focused second pass for security, ownership, and operational fit.

When a team keeps one shared selection rubric, tool adoption speeds up because evaluators stop debating criteria every time a new option appears.

Worked Examples

Example 1: Adding a feature with full skill discipline

  1. Developer asks Claude to add a new feature. Claude detects the feature request and invokes brainstorming before touching code.
  2. Brainstorming skill explores requirements, edge cases, and design options. Developer confirms the plan.
  3. Claude invokes writing-plans, creates a step-by-step implementation plan, then uses test-driven-development during coding.
  4. Before declaring the feature complete, verification-before-completion skill requires running tests and confirming output.

Outcome: The feature ships with requirements understood upfront, tests written before implementation, and verified output before review—not by luck but by enforced workflow.

Example 2: Debugging with systematic root cause analysis

  1. A test fails in CI. Developer asks Claude to fix it.
  2. Claude invokes systematic-debugging before proposing any fix.
  3. The skill enforces: reproduce the problem, identify the root cause, verify understanding before writing a fix.
  4. Claude writes the minimal fix, then uses verification-before-completion to confirm tests pass before marking done.

Outcome: The fix addresses the actual root cause rather than the symptom, and verification runs before the developer is told it is resolved.

Example 3: Parallel workstreams with dispatching agents

  1. A larger task has four independent sub-tasks: write tests, update docs, refactor a module, add a new endpoint.
  2. Claude invokes dispatching-parallel-agents and distributes the sub-tasks to four concurrent subagents.
  3. Each subagent completes its work independently and returns results.
  4. Claude consolidates the outputs and runs a requesting-code-review skill before declaring the batch complete.

Outcome: Multi-stream work completes faster because independent tasks run in parallel rather than serially, without losing the code review gate at the end.

Frequently Asked Questions

What are Superpowers skills for Claude Code?

Superpowers skills are a structured set of pre-built markdown instruction files that extend Claude Code with named, repeatable workflows. Each skill is a document that shapes how Claude reasons, follows process rules, and applies consistent judgment across software projects. Skills are invoked inside Claude Code sessions using the Skill tool or slash commands.

How do I install Superpowers skills in Claude Code?

Skills are typically added to a project's .agent/skills/ directory or a global skill location. After placing the skill files, Claude Code can invoke them by name through the Skill tool (e.g., Skill tool with skill: "brainstorm") or by referencing them in CLAUDE.md for automatic loading. Check the specific package documentation for the full install path.

What is the difference between Superpowers skills and MCP plugins?

Superpowers skills are markdown instruction files that change how Claude reasons and follows workflows—they are behavioral, not tool-providing. MCP plugins are running processes that expose callable tools like database queries or browser automation. You can use both together: skills guide the agent's workflow while MCP plugins supply the external tool actions.

Which Superpowers skills are most useful for developers?

The most impactful developer skills include: brainstorming (explores requirements before coding), TDD (enforces write-tests-first discipline), systematic-debugging (structured approach to root cause analysis), code-review (post-implementation quality check), verification-before-completion (prevents false success claims), and writing-plans (multi-step implementation planning with user confirmation).

Can I create custom Superpowers-style skills?

Yes. A skill is a markdown file with a YAML frontmatter block containing name, description, and type fields. You write the workflow instructions in the body of the file. Once placed in your skill directory, Claude Code can invoke it by name. Custom skills follow the same invocation and file format as the official Superpowers pack.

Do Superpowers skills work with Gemini CLI and Codex?

The Superpowers skill format was originally designed for Claude Code. Gemini CLI has a compatible skill loading system described in GEMINI.md. Codex uses a different instructions format. The core workflow concepts translate across platforms, but the exact invocation mechanism varies by CLI tool.

What is the using-superpowers skill?

The using-superpowers skill is the meta-skill that defines when and how all other skills should be invoked. It enforces a rule that any task with even a 1% chance of matching a skill should invoke it before responding. It also sets the priority ordering for skills: process skills (brainstorming, debugging) first, then implementation skills.

Missing a better tool match?

Send the exact workflow you are solving and we will prioritize a new comparison or rollout guide.

Submit feedback