Skip to content
Back to search

superpowers-antigravity

An agentic skills framework & software development methodology that works. Built natively for Antigravity 2.0, CLI & IDE

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/roundpilot--superpowers-antigravity/badge.svg)](/listings/roundpilot--superpowers-antigravity)

HTML

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

Install

i

Install instructions from the README

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

Antigravity CLI (`agy`)

One command, straight from GitHub:

agy plugin install https://github.com/roundpilot/superpowers-antigravity

Manage with `agy plugin list` / `agy plugin enable superpowers` / `agy plugin disable superpowers`.

> The CLI and the IDE keep independent plugin stores — installing into one does not install into the other.

Antigravity 2.0 IDE (desktop app)

The IDE loads plugins from its config directories — clone this repo into one:

macOS / Linux

**Global plugin** (available in all projects):

git clone https://github.com/roundpilot/superpowers-antigravity ~/.gemini/config/plugins/superpowers

**Workspace plugin** (project-level only):

git clone https://github.com/roundpilot/superpowers-antigravity .agents/plugins/superpowers

**Update later:**

cd ~/.gemini/config/plugins/superpowers && git pull

Windows (PowerShell)

**Global plugin** (available in all projects):

git clone https://github.com/roundpilot/superpowers-antigravity "$env:USERPROFILE\.gemini\config\plugins\superpowers"

**Workspace plugin** (project-level only):

git clone https://github.com/roundpilot/superpowers-antigravity .agents\plugins\superpowers

**Update later:**

cd "$env:USERPROFILE\.gemini\config\plugins\superpowers"; git pull

Windows (WSL)

If you run Antigravity inside WSL, use the Linux paths above.

If you run the **Windows Antigravity IDE** but your workspace is in **WSL**:

# Global plugin (installed on Windows side):
git clone https://github.com/roundpilot/superpowers-antigravity /mnt/c/Users/$USER/.gemini/config/plugins/superpowers

# Workspace plugin (inside your WSL workspace):
git clone https://github.com/roundpilot/superpowers-antigravity /path/to/your/wsl/project/.agents/plugins/superpowers

Manual IDE installation (no git required)

<details> <summary>Download ZIP instead of cloning (click to expand)</summary>

**macOS / Linux:**

curl -L https://github.com/roundpilot/superpowers-antigravity/archive/refs/heads/main.zip -o superpowers.zip
unzip superpowers.zip
mkdir -p ~/.gemini/config/plugins
mv superpowers-antigravity-main ~/.gemini/config/plugins/superpowers
rm superpowers.zip

**Windows (PowerShell):**

Invoke-WebRequest -Uri "https://github.com/roundpilot/superpowers-antigravity/archive/refs/heads/main.zip" -OutFile superpowers.zip
Expand-Archive superpowers.zip -DestinationPath .
New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.gemini\config\plugins"
Move-Item superpowers-antigravity-main "$env:USERPROFILE\.gemini\config\plugins\superpowers"
Remove-Item superpowers.zip

To update later, delete the `superpowers` folder and repeat the steps above.

</details>

Migrating an IDE install from `roundpilot/superpowers`

If you previously installed from `roundpilot/superpowers`, update your remote:

cd ~/.gemini/config/plugins/superpowers
git remote set-url origin https://github.com/roundpilot/superpowers-antigravity.git
git pull

✅ Verify Installation

1. Start a new Antigravity session in any project 2. Type `/using-superpowers` (or `/superpowers:using-superpowers` for the CLI) — the bootstrap loads for the session 3. Alternatively, ask: "What superpowers skills do you have available?" — the agent should enumerate skills from this plugin 4. Say "Let's make a react todo list" 5. The brainstorming skill should trigger automatically — the agent asks design questions instead of writing code

> The slash form isn't on the documented slash-command surface (that page covers workflows), but it works in practice — the palette also surfaces skills. If it ever stops resolving, steps 3-5 are the fallback check.

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.

plugin.json · Manifest · 25 lines

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

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "superpowers",
  3. "displayName": "Superpowers",
  4. "description": "Core skills library for Google Antigravity (2.0 app, IDE and CLI): TDD, debugging, collaboration patterns, and proven techniques",
  5. "version": "7.0.2",
  6. "logo": "assets/antigravity-logo.png",
  7. "suggestedPrompts": [
  8. "I've got an idea for something I'd like to build",
  9. "Let's figure out why this broke"
  10. ],
  11. "author": {
  12. "name": "roundpilot",
  13. "url": "https://github.com/roundpilot"
  14. },
  15. "homepage": "https://github.com/roundpilot/superpowers-antigravity",
  16. "repository": "https://github.com/roundpilot/superpowers-antigravity",
  17. "keywords": [
  18. "skills",
  19. "tdd",
  20. "debugging",
  21. "collaboration",
  22. "best-practices",
  23. "workflows"
  24. ]
  25. }
README.md · README · 357 lines

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

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center">
  2. <img src="docs/banner.png" alt="Superpowers for Antigravity" width="100%">
  3. </p>
  4. <p align="center">
  5. <strong>Superpowers for Google Antigravity: a complete software development methodology for your coding agent.</strong><br>
  6. Composable skills that trigger automatically — your agent just has Superpowers.
  7. </p>
  8. <p align="center">
  9. <a href="https://github.com/roundpilot/superpowers-antigravity#-installation"><img src="https://img.shields.io/badge/Install-Guide-blue?style=for-the-badge" alt="Install"></a>
  10. <a href="https://github.com/roundpilot/superpowers-antigravity/blob/main/RELEASE-NOTES.md"><img src="https://img.shields.io/badge/Version-7.0.2-green?style=for-the-badge" alt="Version 7.0.2"></a>
  11. <a href="https://github.com/obra/superpowers"><img src="https://img.shields.io/badge/Fork%20of-obra%2Fsuperpowers-purple?style=for-the-badge" alt="Fork of obra/superpowers"></a>
  12. <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-yellow?style=for-the-badge" alt="MIT License"></a>
  13. </p>
  14. ---
  15. > **This is a fork of [obra/superpowers](https://github.com/obra/superpowers) rebuilt natively for [Google Antigravity](https://antigravity.google): the 2.0 app, the IDE and the CLI (`agy`).** If you need multi-platform support (Claude Code, Codex, Cursor, etc.), use the upstream repo instead.
  16. **Quick install.** CLI:
  17. ```bash
  18. agy plugin install https://github.com/roundpilot/superpowers-antigravity
  19. ```
  20. 2.0 app and IDE (macOS / Linux; Windows and workspace installs are under [Installation](#-installation)):
  21. ```bash
  22. git clone https://github.com/roundpilot/superpowers-antigravity ~/.gemini/config/plugins/superpowers
  23. ```
  24. ---
  25. ## ✨ How It Works
  26. 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.
  27. How much ceremony follows depends on what you asked for. A quick, clear task just gets done. Otherwise it draws out what you want, and why, plays its understanding back for correction, and has you pick one of two or three approaches. Then it sizes the work: a small change gets a short design doc, and a project gets the full written design, which a builder check reads before you do. What never scales down is the approval: nothing gets built until you say yes.
  28. 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 emphasises true red/green TDD, YAGNI (You Aren't Gonna Need It), and DRY.
  29. 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 agents to work autonomously for a couple hours at a time without deviating from the plan you put together.
  30. 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. (See [Activation](#-activation) for how the loading works — and how to scope it if you don't want it everywhere.)
  31. ## 🔀 What's Different from Upstream?
  32. The original superpowers supports 9+ platforms via a tool mapping abstraction layer — skills are written with Claude Code tool names, and per-platform reference files translate at runtime.
  33. This fork **removes the abstraction entirely**. All skills use native Antigravity tool names directly (`view_file`, `run_command`, `invoke_subagent`, etc.), eliminating translation overhead and making every skill read exactly as the agent will execute it.
  34. <details>
  35. <summary><strong>Why remove cross-platform support?</strong> (click to expand)</summary>
  36. The abstraction layer costs tokens on every interaction, and those costs compound across a session:
  37. 1. **Tool mapping file loaded every session.** The upstream approach loads a ~500-token tool mapping reference into context at session start. Every turn carries this translation table. This fork eliminates it entirely.
  38. 2. **Agent reasoning overhead.** When a skill says "use the Bash tool," the agent must look up the mapping, reason about which native tool to call, and potentially make mistakes. When skills say `run_command` directly, there's zero translation cost.
  39. 3. **Platform-conditional branching in skills.** The upstream `using-superpowers` skill points each harness to its own reference file: Claude Code, Codex, Pi, Antigravity, Hermes Agent and Muse (as of v7.0.2). Only one applies.
  40. 4. **85 fewer files than upstream (as of v7.0.2 on both sides).** When agents explore the repo, fewer files means less noise in `list_dir` output and faster orientation.
  41. 5. **Leaner skills without platform detection.** No harness-detection or fallback branches inside skills — `using-git-worktrees` is 103 lines to upstream's 167 (as of v7.0.2). Shorter skills = less context consumed.
  42. </details>
  43. ### Comparison Table
  44. | Area | Upstream (obra/superpowers) | This fork |
  45. |------|---------------------------|-----------|
  46. | **Platforms** | 9+ (Claude Code, Codex, Cursor, etc.) | Antigravity only (2.0 app, IDE, CLI) |
  47. | **Tool names in skills** | Claude Code names + mapping files | Native Antigravity names |
  48. | **Subagent dispatch** | `Task tool (general-purpose)` | Bundled custom agents + `invoke_subagent` |
  49. | **Workspace isolation** | `git worktree` with fallback | Native `Workspace: "branch"` / `"inherit"` (`"share"` not recommended: its semantics are unverified) |
  50. | **Task tracking** | `TodoWrite` tool | `task.md` artifacts |
  51. | **Visual brainstorming** | Browser-based server | Native `generate_image` (no server needed) |
  52. | **Plan formatting** | Plain markdown | Mermaid diagrams, file links, diff blocks, GitHub alerts |
  53. | **Background tasks** | Not documented | `manage_task`, `send_message`, `schedule` (incl. cron) |
  54. | **UI verification** | Not available | `browser-testing` skill with screenshot evidence |
  55. | **Read-only subagents** | Full tool set for all | Bundled read-only reviewer agents: `spec-reviewer`, `re-reviewer`, `code-reviewer` (one task or a small range) and `final-reviewer` (whole branch, Pro tier) |
  56. | **Web research** | Not guided | `search_web` + `read_url_content` integrated |
  57. ### Core Enhancements
  58. Beyond the platform port, this fork adds capabilities that don't exist upstream:
  59. - 🎨 **`generate_image` in brainstorming** — native mockup generation with carousel comparisons
  60. - 📐 **Rich plan formatting** — Mermaid architecture diagrams, clickable `file:///` links, diff blocks
  61. - 🔄 **Async subagent coordination** — `manage_task` for builds, `send_message` mid-flight, `schedule` for timeouts
  62. - 🌐 **Browser-testing skill** — evidence-before-assertions discipline for UI work
  63. - 💰 **Token-saving subagents** — reviewers are read-only bundled agents
  64. - ✅ **Review gates** — design docs wait for your partner's approval, and plans end with an `ask_question` your partner answers before work goes on
  65. - 🔀 **Workspace mode guidance** — decision tables for `branch` and `inherit` per role; `share` is not recommended (semantics unverified)
  66. - 🛡️ **Edit-time purity gate** — contributors can enable a `PreToolUse` hook (`hooks/purity-check.mjs`, needs `node`) through their global `hooks.json`; the release gate `tests/antigravity/test-skill-tool-purity.sh` enforces the same law. See CONTRIBUTING.
  67. - 🔍 **Web research integration** — `search_web` woven into debugging, brainstorming, and planning
  68. ## 🚀 The Workflow
  69. ```
  70. ┌─────────────┐ ┌──────────────┐ ┌───────────────┐ ┌──────────────────────────┐
  71. │ Brainstorm │ ──▶ │ Write Plan │ ──▶ │ Create Branch │ ──▶ │ Subagent-Driven Dev │
  72. │ │ │ │ │ │ │ ┌────────┐ ┌──────────┐ │
  73. │ • Questions │ │ • Tasks │ │ • Isolated │ │ │Implement│▶│ Review │ │
  74. │ • Mockups │ │ • Diagrams │ │ • Clean base │ │ └────────┘ └──────────┘ │
  75. │ • Design │ │ • Specs │ │ • Tests pass │ │ ↺ per task │
  76. └─────────────┘ └──────────────┘ └───────────────┘ └──────────────────────────┘
  77. │
  78. ▼
  79. ┌──────────────────────────┐
  80. │ Finish Branch │
  81. │ • Final review │
  82. │ • Merge / PR / Keep │
  83. └──────────────────────────┘
  84. ```
  85. 1. **brainstorming** — Draws out what you want, and why, plays it back, has you pick an approach through `ask_question`, then sizes the work as a short or full design doc with a builder check and `generate_image`/Mermaid visuals
  86. 2. **using-git-worktrees** — Isolates the session on a feature branch; concurrent writing subagents get native `Workspace: "branch"`
  87. 3. **writing-plans** — Breaks work into bite-sized tasks with exact file paths and verification steps
  88. 4. **subagent-driven-development** or **executing-plans** — Activates with plan. Either dispatches a fresh subagent per task with a two-stage 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).
  89. 5. **test-driven-development** — RED-GREEN-REFACTOR: write failing test → minimal code → pass → commit
  90. 6. **requesting-code-review** — Reviews against plan, reports issues by severity
  91. 7. **finishing-a-development-branch** — Verifies tests, presents merge/PR/keep options
  92. **Where each executor runs.** subagent-driven-development needs `invoke_subagent` and the plugin's bundled agents — documented for 2.0 and the CLI, not available in the IDE (it has no `invoke_subagent`). executing-plans runs on all three; its final review uses a subagent where one is available.
  93. **Skills trigger automatically.** Mandatory workflows, not suggestions.
  94. ## 🩺 When Something Goes Wrong
  95. 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>`".
  96. 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.
  97. You can also start it directly: `/diagnosing-superpowers` in the 2.0 app or `/superpowers:diagnosing-superpowers` in the CLI.
  98. ## Running long plans
  99. Both executors run a plan to the end, but an approval prompt can park a run. Every task runs read-only git commands (`git rev-parse`, `rev-list`, `merge-base`, `diff`, `log`, `status`), the plan's tests, `git add` and `git commit`.
  100. - **Easiest: Auto mode** (2.0 app 2.23+, 2.26+ on Windows; CLI 1.3.5+, 1.4.4+ on Windows; personal accounts, sandbox required). It asks only about risky or irreversible commands.
  101. - **Otherwise, allow each git subcommand above and the test command**, for example `command(git diff)`. Never allow all of `command(git)`: that lets `git push` through.
  102. - **CLI on Windows:** one rule covers them: `command(regex:git (rev-parse|rev-list|merge-base|diff|log|status|add|commit).*)`. Headless runs (`agy -p`) deny any command not under `permissions.allow`.
  103. - **IDE:** add them to the terminal allowlist. Strict mode ignores it.
  104. - **Don't use `/goal`:** it skips the executors' stops and the finishing menu.
  105. If a subagent's commit approval times out (60 seconds in the CLI), the controller makes the commit itself.
  106. ## 📦 Installation
  107. > **Already installed `obra/superpowers`?** In the CLI, upstream's install most likely uses the same plugin name, `superpowers`, so installing one replaces the other. Run `agy plugin uninstall superpowers` before installing this one. Upstream's install also brings its own session-start bootstrap. In the 2.0 app and the IDE, if a folder named `superpowers` already exists in `~/.gemini/config/plugins/`, move it out of that folder before cloning this one.
  108. ### Antigravity 2.0 app and Antigravity IDE
  109. Both discover plugins in the same folders, so one clone serves both. Install globally unless you want superpowers in chosen projects only.
  110. A workspace install (`.agents/plugins/superpowers`) is project-level. In a 2.0 Project conversation started in New Worktree Mode, check Customizations that superpowers is listed; if it is not, use the global install for those conversations.
  111. #### macOS / Linux
  112. **Global plugin** (available in all projects):
  113. ```bash
  114. git clone https://github.com/roundpilot/superpowers-antigravity ~/.gemini/config/plugins/superpowers
  115. ```
  116. **Workspace plugin** (project-level only):
  117. ```bash
  118. git clone https://github.com/roundpilot/superpowers-antigravity .agents/plugins/superpowers
  119. ```
  120. **Update later:**
  121. ```bash
  122. cd ~/.gemini/config/plugins/superpowers && git pull
  123. ```
  124. #### Windows (PowerShell)
  125. **Global plugin** (available in all projects):
  126. ```powershell
  127. git clone https://github.com/roundpilot/superpowers-antigravity "$env:USERPROFILE\.gemini\config\plugins\superpowers"
  128. ```
  129. **Workspace plugin** (project-level only):
  130. ```powershell
  131. git clone https://github.com/roundpilot/superpowers-antigravity .agents\plugins\superpowers
  132. ```
  133. **Update later:**
  134. ```powershell
  135. cd "$env:USERPROFILE\.gemini\config\plugins\superpowers"; git pull
  136. ```
  137. #### Windows (WSL)
  138. **2.0 app connected to a WSL distribution** (Application Settings): confirm in Settings > Customizations that superpowers is listed. If it is not, clone into `~/.gemini/config/plugins/superpowers` inside the WSL distribution.
  139. If you run the **Windows Antigravity IDE** but your workspace is in **WSL**:
  140. ```bash
  141. # Global plugin (installed on Windows side):
  142. git clone https://github.com/roundpilot/superpowers-antigravity /mnt/c/Users/$USER/.gemini/config/plugins/superpowers
  143. # Workspace plugin (inside your WSL workspace):
  144. git clone https://github.com/roundpilot/superpowers-antigravity /path/to/your/wsl/project/.agents/plugins/superpowers
  145. ```
  146. #### Manual installation for the 2.0 app and the IDE (no git required)
  147. <details>
  148. <summary>Download ZIP instead of cloning (click to expand)</summary>
  149. **macOS / Linux:**
  150. ```bash
  151. curl -L https://github.com/roundpilot/superpowers-antigravity/archive/refs/heads/main.zip -o superpowers.zip
  152. unzip superpowers.zip
  153. mkdir -p ~/.gemini/config/plugins
  154. mv superpowers-antigravity-main ~/.gemini/config/plugins/superpowers
  155. rm superpowers.zip
  156. ```
  157. **Windows (PowerShell):**
  158. ```powershell
  159. Invoke-WebRequest -Uri "https://github.com/roundpilot/superpowers-antigravity/archive/refs/heads/main.zip" -OutFile superpowers.zip
  160. Expand-Archive superpowers.zip -DestinationPath .
  161. New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.gemini\config\plugins"
  162. Move-Item superpowers-antigravity-main "$env:USERPROFILE\.gemini\config\plugins\superpowers"
  163. Remove-Item superpowers.zip
  164. ```
  165. To update later, delete the `superpowers` folder and repeat the steps above.
  166. </details>
  167. #### Migrating a 2.0 app or IDE install from `roundpilot/superpowers`
  168. If you previously installed from `roundpilot/superpowers`, update your remote:
  169. ```bash
  170. cd ~/.gemini/config/plugins/superpowers
  171. git remote set-url origin https://github.com/roundpilot/superpowers-antigravity.git
  172. git pull
  173. ```
  174. #### Troubleshooting
  175. **If superpowers is listed but its skills are never followed,** the agent may not be allowed to read files outside your project: check the IDE's non-workspace file access and strict mode, or, in the 2.0 app on Windows, the project's outside-of-folder file access policy. A workspace install keeps the skills inside the project.
  176. ### Antigravity CLI (`agy`)
  177. ```bash
  178. agy plugin install https://github.com/roundpilot/superpowers-antigravity
  179. ```
  180. If the CLI rejects the URL, clone the repository and install from the folder (to update this way, run `git -C <dir> pull`, then install again):
  181. ```bash
  182. git clone https://github.com/roundpilot/superpowers-antigravity <dir>
  183. agy plugin install <dir>
  184. ```
  185. Inside an `agy` session, `/plugin install <local-path>` does the same as `agy plugin install <dir>`.
  186. - **List:** `agy plugin list`
  187. - **Update:** run the same install command again. It replaces the installed copy, so any edits made inside the installed copy are lost.
  188. - **Disable or enable:** `agy plugin disable superpowers` / `agy plugin enable superpowers`
  189. - **Uninstall:** `agy plugin uninstall superpowers` (it also removes `plugins.superpowers.enabled` from `~/.gemini/config/config.json`)
  190. > CLI 1.2.17 kept its own copy of installed plugins, but current docs say `agy plugin install` writes to `~/.gemini/config/plugins/superpowers`, the folder the app and IDE clone uses. If `agy plugin list` already shows superpowers after you cloned for the app, skip the CLI install: never run both a clone and `agy plugin install` against that folder.
  191. ### ✅ Verify Installation
  192. 1. **Check the product's own view** (no model turn):
  193. - **2.0 app:** Settings > Customizations lists superpowers under Plugins and its 16 skills under Skills.
  194. - **IDE:** the … menu in the agent side panel > Customizations lists superpowers among the active plugin components, with its skills.
  195. - **CLI:** `agy plugin list` shows superpowers and its components; `agy -p "/skills" --output-format json` lists the skills without starting an agent turn.
  196. 2. **Slash command:** type `/using-superpowers` in the 2.0 app or `/superpowers:using-superpowers` in the CLI. The bootstrap loads for the session.
  197. 3. **Behaviour:** say "Let's make a react todo list". The brainstorming skill should trigger and ask design questions instead of writing code.
  198. ## 🔌 Activation
  199. Once installed, the methodology loads itself — no per-session setup:
  200. - **Automatic (default).** The plugin ships the using-superpowers bootstrap as an always-on rule (`rules/using-superpowers.md`), so it loads into every conversation with no setup. Individual skills then trigger on what you ask for: describe a feature and brainstorming starts, report a bug and systematic-debugging starts.
  201. - **Scoped, if you don't want it everywhere.** In the 2.0 app and the IDE, install as a **workspace plugin** (`.agents/plugins/superpowers`) so only chosen projects get it. In the CLI, `agy plugin disable superpowers` turns it off and `agy plugin enable superpowers` turns it back on.
  202. The always-loaded footprint is a single ~55-line bootstrap; individual skills are read only when they trigger.
  203. ## 📚 Skills Reference
  204. ### Testing & Verification
  205. | Skill | Purpose |
  206. |-------|---------|
  207. | **test-driven-development** | RED-GREEN-REFACTOR cycle with the `writing-good-tests` reference (falsifiability rules + mutation check) |
  208. | **browser-testing** | Evidence-before-assertions for UI work (screenshot → DOM inspect → embed proof) |
  209. ### Debugging
  210. | Skill | Purpose |
  211. |-------|---------|
  212. | **systematic-debugging** | 4-phase root cause process with `search_web` for unfamiliar errors |
  213. | **verification-before-completion** | Ensure it's actually fixed; cron schedules for long test suites |
  214. | **diagnosing-superpowers** | Work out what went wrong in a session, with evidence; export a scrubbed bundle or file an issue |
  215. ### Collaboration
  216. | Skill | Purpose |
  217. |-------|---------|
  218. | **brainstorming** | Draws out intent and why first; approaches picked through `ask_question`; Size the Work (short or full design doc); a builder check; `generate_image` mockups and Mermaid diagrams |
  219. | **writing-plans** | Detailed plans with Mermaid diagrams, rich formatting, an `ask_question` review gate, and a `Spec:` pointer so the spec travels with the plan |
  220. | **executing-plans** | Inline plan execution: one context, one final review |
  221. | **dispatching-parallel-agents** | Concurrent workflows with `Workspace: "branch"` / `"inherit"` and monitoring |
  222. | **requesting-code-review** | Bundled `code-reviewer` (one task or a small range) and Pro-tier `final-reviewer` (whole branch), with severity classification |
  223. | **receiving-code-review** | Responding to feedback with technical rigor |
  224. | **using-git-worktrees** | Workspace isolation with mode decision table |
  225. | **finishing-a-development-branch** | Merge/PR decision workflow |
  226. | **subagent-driven-development** | Fast iteration with two-stage task review and async coordination; resume-based fix loop with five-round cap; records rulings instead of stalling, and batches small same-shape tasks into one dispatch |
  227. ### Meta
  228. | Skill | Purpose |
  229. |-------|---------|
  230. | **writing-skills** | Create new skills following best practices |
  231. | **using-superpowers** | Introduction to the skills system |
  232. ### Bundled agents
  233. | Agent | Tier | Role |
  234. |-------|------|------|
  235. | `implementer` | inherit | Implements one plan task in subagent-driven development, and fixes review findings |
  236. | `implementer-flash` | flash | The same, for tasks whose plan gives the complete code and for single-file mechanical fixes |
  237. | `implementer-pro` | pro | The same, for escalations and design work when your session runs below Pro |
  238. | `spec-reviewer` | inherit | Read-only: checks one task's implementation against its task text |
  239. | `code-reviewer` | inherit | Read-only: reviews code quality for one task or a small range |
  240. | `re-reviewer` | inherit | Read-only: verifies a fix round |
  241. | `final-reviewer` | pro | Read-only: reviews the whole branch before merge, for both executors |
  242. | `session-analyst` | inherit | Read-only: analyses session transcripts for diagnosing-superpowers |
  243. | `bundle-scrubber` | inherit | Redacts an exported diagnosis bundle for diagnosing-superpowers |
  244. `inherit` runs your session's model. `final-reviewer` ships at the Pro tier; which model that is, is not documented. Agent files can name only `inherit`, `flash` or `pro`, not a model or a reasoning effort, and plans differ in which models they offer, so check that a Pro-tier agent runs on your plan. It may run a different model family from your session's.
  245. ## 🧭 Philosophy
  246. - **Test-Driven Development** — Write tests first, always
  247. - **Systematic over ad-hoc** — Process over guessing
  248. - **Complexity reduction** — Simplicity as primary goal
  249. - **Evidence over claims** — Verify before declaring success
  250. ## 🤝 Contributing
  251. See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines, PR requirements, and quality standards.
  252. ## 📜 License
  253. MIT License — see [LICENSE](LICENSE) for details.
  254. ## 🙏 Acknowledgements
  255. This project is a fork of [obra/superpowers](https://github.com/obra/superpowers). If Superpowers has helped you, consider [sponsoring the original project](https://github.com/sponsors/obra).

Ratings and comments

Sign in to rate this skill.

Sign in

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