Skip to content
Back to search

superpowers-dev

MarketplaceWorks with Claude CodeGitHub

Development marketplace for Superpowers core skills library

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/obra-superpowers/badge.svg)](/listings/obra-superpowers)

HTML

<a href="/listings/obra-superpowers"><img src="/api/listings/obra-superpowers/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Installation differs by harness. If you use more than one, install Superpowers separately for each one.

Claude Code

Superpowers is available via the [official Claude plugin marketplace](https://claude.com/plugins/superpowers)

Official Marketplace

- Install the plugin from Anthropic's official marketplace:

  /plugin install superpowers@claude-plugins-official

Superpowers Marketplace

The Superpowers marketplace provides Superpowers and some other related plugins for Claude Code.

- Register the marketplace:

  /plugin marketplace add obra/superpowers-marketplace

- Install the plugin from this marketplace:

  /plugin install superpowers@superpowers-marketplace

Antigravity

Install Superpowers as a plugin from this repository:

agy plugin install https://github.com/obra/superpowers

Antigravity lists each installed skill's description, and the description of the `using-superpowers` skill prompts the model to load that skill at the start of a conversation. Reinstall with the same command to update.

Codex App

Superpowers is available via the [official Codex plugin marketplace](https://github.com/openai/plugins).

- In the Codex app, click on Plugins in the sidebar. - You should see `Superpowers` in the Coding section. - Click the `+` next to Superpowers and follow the prompts.

Codex CLI

Superpowers is available via the [official Codex plugin marketplace](https://github.com/openai/plugins).

- Open the plugin search interface:

  /plugins

- Search for Superpowers:

  superpowers

- Select `Install Plugin`.

Cursor

- In Cursor Agent chat, install from marketplace:

  /add-plugin superpowers

- Or search for "superpowers" in the plugin marketplace.

Devin CLI

- Install the plugin from this repository:

  devin plugins install obra/superpowers

- Update to the latest version with:

  devin plugins update superpowers

Factory Droid

- Register the marketplace:

  droid plugin marketplace add https://github.com/obra/superpowers

- Install the plugin:

  droid plugin install superpowers@superpowers

Gemini CLI

- Install the extension:

  gemini extensions install https://github.com/obra/superpowers

- Update later:

  gemini extensions update superpowers

GitHub Copilot CLI

- Register the marketplace:

  copilot plugin marketplace add obra/superpowers-marketplace

- Install the plugin:

  copilot plugin install superpowers@superpowers-marketplace

Grok Build CLI

Superpowers is available via the [official Grok plugin marketplace](https://github.com/xai-org/plugin-marketplace).

- Install the plugin from xAI's official marketplace:

  grok plugin install superpowers@xai-official --trust

- Or open the marketplace in the TUI, search for Superpowers, and install it:

  /marketplace

Kimi Code

Superpowers is available in Kimi Code's plugin marketplace.

- Open Kimi Code's plugin manager:

  /plugins

- Go to `Marketplace` > `Superpowers` and install it.

- Or install directly from this repository:

  /plugins install https://github.com/obra/superpowers

- Detailed docs: [docs/README.kimi.md](docs/README.kimi.md)

OpenCode

OpenCode uses its own plugin install; install Superpowers separately even if you already use it in another harness.

- Tell OpenCode:

  Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.opencode/INSTALL.md

- Detailed docs: [docs/README.opencode.md](docs/README.opencode.md)

Pi

Install Superpowers as a Pi package from this repository:

pi install git:github.com/obra/superpowers

For local development, run Pi with this checkout loaded as a temporary package:

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 20 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "superpowers-dev",
  3. "description": "Development marketplace for Superpowers core skills library",
  4. "owner": {
  5. "name": "Jesse Vincent",
  6. "email": "jesse@fsck.com"
  7. },
  8. "plugins": [
  9. {
  10. "name": "superpowers",
  11. "description": "Core skills library for Claude Code: TDD, debugging, collaboration patterns, and proven techniques",
  12. "version": "7.0.2",
  13. "source": "./",
  14. "author": {
  15. "name": "Jesse Vincent",
  16. "email": "jesse@fsck.com"
  17. }
  18. }
  19. ]
  20. }
README.md · README · 400 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Superpowers
  2. Superpowers is a complete software development methodology for your coding agents, built on top of a set of composable skills and some initial instructions that make sure your agent uses them.
  3. ## Table of Contents
  4. - [How it works](#how-it-works)
  5. - [Commercial Services](#commercial-services)
  6. - [Getting Started](#installation)
  7. - [Claude Code](#claude-code)
  8. - [Antigravity](#antigravity)
  9. - [Codex App](#codex-app)
  10. - [Codex CLI](#codex-cli)
  11. - [Cursor](#cursor)
  12. - [Devin CLI](#devin-cli)
  13. - [Factory Droid](#factory-droid)
  14. - [Gemini CLI](#gemini-cli)
  15. - [GitHub Copilot CLI](#github-copilot-cli)
  16. - [Grok Build CLI](#grok-build-cli)
  17. - [Kimi Code](#kimi-code)
  18. - [OpenCode](#opencode)
  19. - [Pi](#pi)
  20. - [Qwen Code](#qwen-code)
  21. - [Hermes Agent](#hermes-agent)
  22. - [Muse](#muse)
  23. - [The Basic Workflow](#the-basic-workflow)
  24. - [When Something Goes Wrong](#when-something-goes-wrong)
  25. - [Community](#community)
  26. - [What's Inside](#whats-inside)
  27. - [Philosophy](#philosophy)
  28. - [Contributing](#contributing)
  29. - [Updating](#updating)
  30. - [License](#license)
  31. - [Visual companion telemetry](#visual-companion-telemetry)
  32. ## How it works
  33. It starts from the moment you fire up your coding agent. As soon as it sees that you're building something, it *doesn't* just jump into trying to write code. Instead, it steps back and asks you what you're really trying to do.
  34. Once it's teased a spec out of the conversation, it shows it to you in chunks short enough to actually read and digest.
  35. After you've signed off on the design, your agent puts together an implementation plan that's clear enough for an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing to follow. It emphasizes true red/green TDD, YAGNI (You Aren't Gonna Need It), and DRY.
  36. Next up, once you say "go", it launches a *subagent-driven-development* process, having agents work through each engineering task, inspecting and reviewing their work, and continuing forward. It's not uncommon for your agent to work autonomously for a couple hours at a time without deviating from the plan you put together.
  37. There's a bunch more to it, but that's the core of the system. And because the skills trigger automatically, you don't need to do anything special. Your coding agent just has Superpowers.
  38. ## Commercial Services
  39. If you're using Superpowers in enterprise and could benefit from commercial support, additional tooling, or managed spending, please don't hesitate to drop us a line at sales@primeradiant.com.
  40. ## Installation
  41. Installation differs by harness. If you use more than one, install Superpowers separately for each one.
  42. ### Claude Code
  43. Superpowers is available via the [official Claude plugin marketplace](https://claude.com/plugins/superpowers)
  44. #### Official Marketplace
  45. - Install the plugin from Anthropic's official marketplace:
  46. ```bash
  47. /plugin install superpowers@claude-plugins-official
  48. ```
  49. #### Superpowers Marketplace
  50. The Superpowers marketplace provides Superpowers and some other related plugins for Claude Code.
  51. - Register the marketplace:
  52. ```bash
  53. /plugin marketplace add obra/superpowers-marketplace
  54. ```
  55. - Install the plugin from this marketplace:
  56. ```bash
  57. /plugin install superpowers@superpowers-marketplace
  58. ```
  59. ### Antigravity
  60. Install Superpowers as a plugin from this repository:
  61. ```bash
  62. agy plugin install https://github.com/obra/superpowers
  63. ```
  64. Antigravity lists each installed skill's description, and the description of
  65. the `using-superpowers` skill prompts the model to load that skill at the start
  66. of a conversation. Reinstall with the same command to update.
  67. ### Codex App
  68. Superpowers is available via the [official Codex plugin marketplace](https://github.com/openai/plugins).
  69. - In the Codex app, click on Plugins in the sidebar.
  70. - You should see `Superpowers` in the Coding section.
  71. - Click the `+` next to Superpowers and follow the prompts.
  72. ### Codex CLI
  73. Superpowers is available via the [official Codex plugin marketplace](https://github.com/openai/plugins).
  74. - Open the plugin search interface:
  75. ```bash
  76. /plugins
  77. ```
  78. - Search for Superpowers:
  79. ```bash
  80. superpowers
  81. ```
  82. - Select `Install Plugin`.
  83. ### Cursor
  84. - In Cursor Agent chat, install from marketplace:
  85. ```text
  86. /add-plugin superpowers
  87. ```
  88. - Or search for "superpowers" in the plugin marketplace.
  89. ### Devin CLI
  90. - Install the plugin from this repository:
  91. ```bash
  92. devin plugins install obra/superpowers
  93. ```
  94. - Update to the latest version with:
  95. ```bash
  96. devin plugins update superpowers
  97. ```
  98. ### Factory Droid
  99. - Register the marketplace:
  100. ```bash
  101. droid plugin marketplace add https://github.com/obra/superpowers
  102. ```
  103. - Install the plugin:
  104. ```bash
  105. droid plugin install superpowers@superpowers
  106. ```
  107. ### Gemini CLI
  108. - Install the extension:
  109. ```bash
  110. gemini extensions install https://github.com/obra/superpowers
  111. ```
  112. - Update later:
  113. ```bash
  114. gemini extensions update superpowers
  115. ```
  116. ### GitHub Copilot CLI
  117. - Register the marketplace:
  118. ```bash
  119. copilot plugin marketplace add obra/superpowers-marketplace
  120. ```
  121. - Install the plugin:
  122. ```bash
  123. copilot plugin install superpowers@superpowers-marketplace
  124. ```
  125. ### Grok Build CLI
  126. Superpowers is available via the [official Grok plugin marketplace](https://github.com/xai-org/plugin-marketplace).
  127. - Install the plugin from xAI's official marketplace:
  128. ```bash
  129. grok plugin install superpowers@xai-official --trust
  130. ```
  131. - Or open the marketplace in the TUI, search for Superpowers, and install it:
  132. ```text
  133. /marketplace
  134. ```
  135. ### Kimi Code
  136. Superpowers is available in Kimi Code's plugin marketplace.
  137. - Open Kimi Code's plugin manager:
  138. ```text
  139. /plugins
  140. ```
  141. - Go to `Marketplace` > `Superpowers` and install it.
  142. - Or install directly from this repository:
  143. ```text
  144. /plugins install https://github.com/obra/superpowers
  145. ```
  146. - Detailed docs: [docs/README.kimi.md](docs/README.kimi.md)
  147. ### OpenCode
  148. OpenCode uses its own plugin install; install Superpowers separately even if you
  149. already use it in another harness.
  150. - Tell OpenCode:
  151. ```
  152. Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.opencode/INSTALL.md
  153. ```
  154. - Detailed docs: [docs/README.opencode.md](docs/README.opencode.md)
  155. ### Pi
  156. Install Superpowers as a Pi package from this repository:
  157. ```bash
  158. pi install git:github.com/obra/superpowers
  159. ```
  160. For local development, run Pi with this checkout loaded as a temporary package:
  161. ```bash
  162. pi -e /path/to/superpowers
  163. ```
  164. The Pi package loads the Superpowers skills and a small extension that injects the `using-superpowers` bootstrap at session startup and again after compaction. Pi has native skills, so no compatibility `Skill` tool is required. Subagent and task-list tools remain optional Pi companion packages.
  165. ### Qwen Code
  166. Qwen Code installs plugins from Claude Code marketplaces directly.
  167. - Install the plugin from this repository, and pick `superpowers` when prompted:
  168. ```bash
  169. qwen extensions install obra/superpowers
  170. ```
  171. - Update later:
  172. ```bash
  173. qwen extensions update superpowers
  174. ```
  175. ### Hermes Agent
  176. Install Superpowers as a Hermes plugin from this repository:
  177. ```bash
  178. hermes plugins install obra/superpowers --enable
  179. ```
  180. Restart any active Hermes sessions after installing. Note: Hermes has no
  181. post-compaction hook, so a very long session that compacts over its first
  182. turn loses the bootstrap — start a fresh session if skills stop triggering.
  183. ### Muse
  184. Superpowers is available as a native Muse plugin — same repo, same skills, all harnesses. The `using-superpowers` bootstrap is injected via the native `SessionStart` hook alongside Claude Code, Codex, Cursor, Gemini, Pi, and the rest — no per-session opt-in.
  185. - Install from a local checkout:
  186. ```bash
  187. muse plugins install ./
  188. muse plugins approve superpowers
  189. ```
  190. Or clone and install:
  191. ```bash
  192. git clone https://github.com/obra/superpowers.git
  193. muse plugins install ./superpowers
  194. muse plugins approve superpowers
  195. ```
  196. - Update later:
  197. ```bash
  198. muse plugins update superpowers
  199. ```
  200. Restart any active Muse sessions after installing so the `SessionStart` hook takes effect — skills are active immediately, hooks require approval on first install. To verify, start a fresh session and send `Let's make a react todo list` — a working install auto-triggers `brainstorming` before any code is written. Version is tracked in `.version-bump.json` so `scripts/bump-version.sh` keeps it in sync.
  201. ## The Basic Workflow
  202. 1. **brainstorming** - Activates before building anything. Draws out what you actually want, and why, through questions that get you describing it, then plays its understanding back for correction. Small changes get agreed in chat; projects get a written design document a builder could plan from.
  203. 2. **using-git-worktrees** - Activates after design approval. Creates isolated workspace on new branch, runs project setup, verifies clean test baseline.
  204. 3. **writing-plans** - Activates with approved design. Breaks work into bite-sized tasks (2-5 minutes each). Every task has exact file paths, complete code, verification steps.
  205. 4. **subagent-driven-development** or **executing-plans** - Activates with plan. Either dispatches a fresh subagent per task with a review after each (most thorough), or implements every task inline in the current session with one fresh review of the whole branch at the end (cheapest).
  206. 5. **test-driven-development** - Activates during implementation. Enforces RED-GREEN-REFACTOR: write failing test, watch it fail, write minimal code, watch it pass, commit. Deletes code written before tests.
  207. 6. **requesting-code-review** - Activates between tasks. Reviews against plan, reports issues by severity. Critical issues block progress.
  208. 7. **finishing-a-development-branch** - Activates when tasks complete. Verifies tests, presents options (merge/PR/keep/discard), cleans up worktree.
  209. **The agent checks for relevant skills before any task.** Mandatory workflows, not suggestions.
  210. ## When Something Goes Wrong
  211. Sometimes a session misbehaves: a skill fires when it shouldn't, stays silent when it should, or the agent ignores its plan, repeats work, or burns more tokens than you'd expect. Ask your coding agent to "figure out what went wrong with superpowers in this session" and it will invoke the **diagnosing-superpowers** skill. To examine an earlier session, name it: "figure out what went wrong with superpowers in session `<id>`".
  212. The skill reads the session transcript, reports what happened with line-level evidence, and, if you want, packages a scrubbed bundle for a bug report.
  213. ## Community
  214. Superpowers is built by [Jesse Vincent](https://blog.fsck.com) and the rest of the folks at [Prime Radiant](https://primeradiant.com).
  215. - **Discord**: [Join us](https://discord.gg/35wsABTejz) for community support, questions, and sharing what you're building with Superpowers
  216. - **Issues**: https://github.com/obra/superpowers/issues
  217. - **Release announcements**: [Sign up](https://primeradiant.com/superpowers/) to get notified about new versions
  218. ## What's Inside
  219. ### Skills Library
  220. **Testing**
  221. - **test-driven-development** - RED-GREEN-REFACTOR cycle (includes testing anti-patterns reference)
  222. **Debugging**
  223. - **systematic-debugging** - 4-phase root cause process (includes root-cause-tracing, defense-in-depth, condition-based-waiting techniques)
  224. - **verification-before-completion** - Ensure it's actually fixed
  225. - **diagnosing-superpowers** - Work out what went wrong in a session, with evidence; export a scrubbed bundle or file an issue
  226. **Collaboration**
  227. - **brainstorming** - Drawing out intent before building
  228. - **writing-plans** - Detailed implementation plans
  229. - **executing-plans** - Inline plan execution: one context, one final review
  230. - **dispatching-parallel-agents** - Concurrent subagent workflows
  231. - **requesting-code-review** - Pre-review checklist
  232. - **receiving-code-review** - Responding to feedback
  233. - **using-git-worktrees** - Parallel development branches
  234. - **finishing-a-development-branch** - Merge/PR decision workflow
  235. - **subagent-driven-development** - Fast iteration with two-stage review (spec compliance, then code quality)
  236. **Meta**
  237. - **writing-skills** - Create new skills following best practices (includes testing methodology)
  238. - **using-superpowers** - Introduction to the skills system
  239. ## Philosophy
  240. - **Test-Driven Development** - Write tests first, always
  241. - **Systematic over ad-hoc** - Process over guessing
  242. - **Complexity reduction** - Simplicity as primary goal
  243. - **Evidence over claims** - Verify before declaring success
  244. Read [the original release announcement](https://blog.fsck.com/2025/10/09/superpowers/).
  245. ## Contributing
  246. The general contribution process for Superpowers is below. Keep in mind that we don't generally accept contributions of new skills and that any updates to skills must work across all of the coding agents we support. We also don't accept agent-written PRs that fix issues filed by someone else unless a maintainer asked for one, even when you hit the same problem; add your report to the existing issue instead.
  247. 1. Fork the repository
  248. 2. Switch to the 'dev' branch
  249. 3. Create a branch for your work
  250. 4. Follow the `writing-skills` skill for creating and testing new and modified skills
  251. 5. Submit a PR, filling in every section of the pull request template, including the summary a human writes in their own words.
  252. Skill-behavior tests use the drill eval harness from [superpowers-evals](https://github.com/prime-radiant-inc/superpowers-evals/), cloned into `evals/` — see `evals/README.md` for setup. Plugin-infrastructure tests live at `tests/` and run via the relevant `run-*.sh` or `npm test`.
  253. See `skills/writing-skills/SKILL.md` for the complete guide.
  254. ## Updating
  255. Superpowers updates are somewhat coding-agent dependent, but are often automatic.
  256. ## License
  257. MIT License - see LICENSE file for details
  258. ## Visual companion telemetry
  259. Because skills and plugins don't provide any feedback to creators, we have no idea how many of you are using Superpowers. By default, the Prime Radiant logo on brainstorming's optional visual companion feature is loaded from our website. It includes the version of Superpowers in use. It does not include any details about your project, prompt, or coding agent. We don't see your clicks or anything about what you're building. This helps us have a rough idea of how many folks are using Superpowers and which version of Superpowers they're using. It's 100% optional. To disable this, set the environment variable `SUPERPOWERS_DISABLE_TELEMETRY` to any true value. Superpowers also honors Claude Code's `DISABLE_TELEMETRY` and `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` opt-outs.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.