obra/superpowers
14 skills2M installs3M starsGitHub
Install
npx skills add https://github.com/obra/superpowersSkills in this repo
1BrainstormingBrainstorming is a journey-wide Superpowers agent skill that turns rough ideas into approved designs through guided conversation instead of immediate coding. Solo and indie builders install it so Claude Code, Cursor, Codex, or similar agents must understand project context, ask clarifying questions one at a time, and present a design for sign-off before any implementation skill runs. The HARD-GATE applies to every project—features, components, behavior changes, and allegedly trivial work—because unexamined assumptions waste the most time on small tasks. The workflow combines context exploration, optional visual companion messaging for UI topics, requirement refinement, and design review. Use it whenever creative work is about to start and you want a citable, repeatable ritual that pairs with downstream planning skills in the same repo when your stack defines them.209kinstalls2Using SuperpowersUsing Superpowers is a journey-wide meta skill for solo and indie builders who run Claude Code, Codex, Cursor, or similar agents with a skills.sh-style library. It does not implement features itself; it installs a mandatory habit—before you plan, debug, review, or ship, you check whether a procedural skill applies and invoke it through the Skill tool (or your platform’s native skill loader) instead of improvising in chat. That matters because agents default to jumping straight to implementation, which wastes time on wrong approaches and misses checklists that skills already encode. The workflow is explicit: scan for relevant skills, invoke the best match (including brainstorming or debugging skills in early phases), then announce usage and follow the skill’s instructions—including any required sub-skill chain—before touching files or shells. The bundled readme also documents Codex tool mapping and multi-agent flags so parallel and subagent skills stay usable. Treat it as the operating system layer for every other superpowers skill in your catalog install.134kinstalls3Systematic DebuggingSystematic Debugging is an agent skill that forces a root-cause-first workflow before any proposed fix for bugs, test failures, build breaks, integration glitches, or odd runtime behavior. Solo builders use it to stop agents (and themselves) from shipping quick patches that mask real defects, especially under deadline pressure when “one obvious line change” feels tempting. The skill encodes The Iron Law—no fixes without completed Phase 1 investigation—and walks through investigation, hypothesis framing, minimal targeted changes, and verification loops. It fits Claude Code, Cursor, Codex, and similar agents whenever procedural discipline matters more than speed-of-guesswork. Pair it with code review or TDD skills after you have a reproducible failure and a traced causal chain, not as a substitute for reading stack traces or writing a minimal repro.134kinstalls4Writing PlansWriting Plans is a Superpowers agent skill for solo and indie builders who already have a spec or requirements and need a disciplined bridge before any code changes. It instructs the agent to announce use of the skill, map which files will be created or modified, and produce a comprehensive markdown plan saved under docs/superpowers/plans/YYYY-MM-DD-feature-name.md (unless the user overrides the path). Each task is bite-sized and documents code changes, testing approach, docs to consult, and verification steps—written for a skilled developer who does not know your stack or domain. If a spec spans independent subsystems, the skill prompts splitting into separate plans so each delivers working, testable software. It pairs naturally with brainstorming for scope and with git worktrees when executing in isolation. Use it whenever multi-step implementation risk is high and you want reproducible agent runs instead of ad-hoc chat planning.133kinstalls5Requesting Code ReviewRequesting Code Review is an agent skill from the Superpowers collection that gives solo and indie builders a copy-ready Task subagent prompt for senior-level review. Instead of asking the main agent to skim changes in chat, you fill in what was implemented, the requirements or plan, and base/head SHAs so the reviewer pulls the right git diff and judges the work against agreed scope. The rubric covers whether the implementation matches the plan, separation of concerns, error handling, type safety, DRY balance, edge cases, scalability, security, and tests that assert real behavior rather than mocks alone. It fits Claude Code-style workflows where you delegate review to a general-purpose subagent before opening or merging a PR. Use it when a milestone is done and you want a consistent gate—not for drive-by opinions on unrelated files.119kinstalls6Test Driven DevelopmentTest-Driven Development is an agent skill from obra/superpowers that forces a test-first implementation ritual: write a failing test, confirm it fails for the right reason, add the smallest code to pass, then refactor. It is aimed at solo and indie builders who use Claude Code, Cursor, or Codex and want agents to stop shipping speculative implementations that are hard to verify. Use it whenever you implement a new feature, fix a bug, change behavior, or refactor—unless you and your partner explicitly exempt throwaway prototypes, generated boilerplate, or pure config. The skill stresses that skipping “just once” is rationalization and that peeking at pre-written implementation invalidates the test. For Prism’s journey, it sits primarily in Build as a procedural guardrail that also strengthens Ship testing habits without replacing your test runner or CI setup.118kinstalls7Executing PlansExecuting-plans is a Superpowers agent skill for solo builders who already have a markdown implementation plan and want a separate focused session to implement it without drifting. You announce the skill, read the plan file, review it critically, raise blockers with your human partner before coding, then walk every task: mark in progress, follow steps exactly, run the plan’s verification commands, and mark complete. It tells you when to stop immediately—missing dependencies, failing tests, broken verifications, or ambiguous requirements—instead of guessing. After all tasks pass, it requires the finishing-a-development-branch sub-skill so tests and merge/PR choices are handled consistently. The readme notes that platforms with subagents (Claude Code, Codex) should prefer subagent-driven-development for higher quality; this skill remains the straightforward sequential executor when you are not using that path. It pairs naturally with writing-plans and fits any repo-based product shape where plans live in version control.109kinstalls8Subagent Driven DevelopmentSuperpowers pattern for executing implementation plans by delegating each independent task to a new subagent, enforcing dual review gates, and avoiding mid-run progress pings that slow solo builders down.102kinstalls9Verification Before CompletionVerification Before Completion is an agent skill from the Superpowers lineage that blocks premature success claims during solo and indie shipping workflows. It applies whenever you or your agent are about to say work is complete, fixed, or passing—especially right before a git commit or pull request—and requires running the full verification command in the current turn, reading exit codes and failure counts, and only then stating status with evidence attached. For Claude Code, Cursor, Codex, and similar agents, it turns “should pass” and “looked fine last time” into an explicit evidence-before-assertions habit that matches how real CI and code review work. The skill is lightweight procedural knowledge (SKILL.md) rather than an MCP integration: no APIs, just discipline at the moment claims matter most. Use it on every meaningful handoff from build to ship and when closing bug-fix loops so your catalog of agent capabilities stays trustworthy under scrutiny from teammates, users, and search-facing documentation you publish about your process.100kinstalls10Receiving Code ReviewSuperpowers methodology for agents receiving code review: prioritize technical correctness over social comfort, verify every suggestion against the repo, and implement changes incrementally with tested steps.96.2kinstalls11Writing SkillsSuperpowers guide for writing agent skills by running pressure scenarios with subagents, observing baseline failures, documenting proven techniques, and closing compliance gaps—mirroring RED-GREEN-REFACTOR for process docs.95.5kinstalls12Dispatching Parallel AgentsSuperpowers pattern for delegating 2+ independent tasks to parallel agents with tightly scoped instructions and isolated context, avoiding sequential investigation waste while you coordinate outcomes.93.6kinstalls13Using Git WorktreesWorkflow skill that verifies whether you are already in an isolated workspace, uses native harness worktrees when available, and otherwise creates a git worktree with sane project setup.93.5kinstalls14Finishing A Development BranchCompletion skill that runs tests first, detects git/worktree state, then guides the user through merge, pull request, retention, or cleanup workflows.91.4kinstalls