superpowers-workflow
A disciplined operating procedure for software tasks, enforcing planning, verification, and risk management.
Install
mkdir -p .claude/skills/superpowers-workflow && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/3172" && unzip -o skill.zip -d .claude/skills/superpowers-workflow && rm skill.zipInstalls to .claude/skills/superpowers-workflow
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Enforces a disciplined workflow for coding, debugging, refactoring, and automation: brainstorm -> plan -> implement with verification (prefer TDD) -> review -> finish. Use for almost any non-trivial change.Key capabilities
- →Brainstorm project goals and risks
- →Create structured implementation plans
- →Execute TDD-based development
- →Perform systematic review passes
- →Verify changes with observable checks
How it works
The skill enforces a mandatory workflow of brainstorming, planning, implementation, review, and verification to ensure disciplined software development.
Inputs & outputs
When to use superpowers-workflow
- →Implementing new features
- →Debugging complex failures
- →Refactoring existing code
- →Designing automation pipelines
- →Adding security/reliability checks
About this skill
Superpowers Workflow
This skill defines the default operating procedure for software and automation tasks.
When to use this skill
Use whenever the user asks to:
- build or modify code
- debug an error or failing tests
- refactor or improve quality
- design an automation workflow (e.g., API integrations, ETL, pipelines)
- add tests, reliability, or safety checks
Activation marker (required)
Immediately after reading this skill (before any other output), run:
python .agent/skills/superpowers-workflow/scripts/record_activation.py --skill superpowers-workflow
Default workflow (mandatory unless explicitly unnecessary)
- Brainstorm (short): clarify goal, constraints, risks, and acceptance criteria.
- Write a plan: small steps (2–10 minutes each) with files + verification.
- Implement: make the smallest correct change; prefer tests-first when feasible.
- Review pass: correctness, edge cases, security, style, maintainability.
- Finish: run verification commands, summarize changes + next steps.
Decision tree: how much process is needed?
- Tiny change (1 file, obvious):
- Do a mini-brainstorm (3 bullets), then mini-plan (3–5 steps), then implement + verify.
- Non-trivial change:
- Full brainstorm + plan before editing.
- High-risk change (auth, money, prod data, security, migrations):
- Add explicit risk controls: rollback plan, dry-run, extra tests, logging, safe defaults.
Output rules (how you communicate)
- Always state assumptions if anything is ambiguous.
- Always include verification (commands, tests, or observable checks).
- If you must ask questions, ask at most 3; then proceed with best assumptions.
Stop conditions
Pause implementation and switch to planning if:
- requirements conflict
- critical unknowns block correctness
- the change could cause data loss or security issues without safeguards
When not to use it
- →Trivial tasks where process overhead exceeds work time
Prerequisites
Limitations
- →Requires activation script execution
- →Process-heavy for tiny changes
How it compares
It mandates a structured lifecycle and risk controls for non-trivial changes instead of ad-hoc coding.
Compared to similar skills
superpowers-workflow side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| superpowers-workflow (this skill) | 8 | 6mo | Review | Beginner |
| clojure-write | 16 | 3mo | No flags | Intermediate |
| code-execution | 1 | 9mo | No flags | Advanced |
| ace-pattern-learning | 0 | 4mo | No flags | Beginner |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by anthonylee991
View all by anthonylee991 →You might also like
clojure-write
metabase
Guide Clojure and ClojureScript development using REPL-driven workflow, coding conventions, and best practices. Use when writing, developing, or refactoring Clojure/ClojureScript code.
code-execution
mhattingpete
Execute Python code locally with marketplace API access for 90%+ token savings on bulk operations. Activates when user requests bulk operations (10+ files), complex multi-step workflows, iterative processing, or mentions efficiency/performance.
ace-pattern-learning
ce-dot-net
Search ACE playbook before implementing, building, fixing, debugging, or refactoring code. Capture patterns after completing substantial coding work.
godot
bfollington
This skill should be used when working on Godot Engine projects. It provides specialized knowledge of Godot's file formats (.gd, .tscn, .tres), architecture patterns (component-based, signal-driven, resource-based), common pitfalls, validation tools, code templates, and CLI workflows. The `godot` command is available for running the game, validating scripts, importing resources, and exporting builds. Use this skill for tasks involving Godot game development, debugging scene/resource files, implementing game systems, or creating new Godot components.
software-architecture
davila7
Guide for quality focused software architecture. This skill should be used when users want to write code, design architecture, analyze code, in any case that relates to software development.
unreal-engine-cpp-pro
sickn33
Expert guide for Unreal Engine 5.x C++ development, covering UObject hygiene, performance patterns, and best practices.