GitHub - roundpilot/superpowers-antigravity: Superpowers for Google Antigravity: a native plugin for the 2.0 app, IDE and agy CLI. Brainstorming, planning, TDD and subagent-driven development skills.

Superpowers for Google Antigravity: a complete software development methodology for your coding agent.
Composable skills that trigger automatically — your agent just has Superpowers.

This is a fork of obra/superpowers rebuilt natively for Google Antigravity: 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.

Quick install. CLI:

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

2.0 app and IDE (macOS / Linux; Windows and workspace installs are under Installation):

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

✨ How It Works

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.

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.

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.

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.

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 for how the loading works — and how to scope it if you don't want it everywhere.)

🔀 What's Different from Upstream?

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.

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.

Why remove cross-platform support? (click to expand)

The abstraction layer costs tokens on every interaction, and those costs compound across a session:

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.
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.
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.
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.
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.

Comparison Table

Area	Upstream (obra/superpowers)	This fork
Platforms	9+ (Claude Code, Codex, Cursor, etc.)	Antigravity only (2.0 app, IDE, CLI)
Tool names in skills	Claude Code names + mapping files	Native Antigravity names
Subagent dispatch	`Task tool (general-purpose)`	Bundled custom agents + `invoke_subagent`
Workspace isolation	`git worktree` with fallback	Native `Workspace: "branch"` / `"inherit"` (`"share"` not recommended: its semantics are unverified)
Task tracking	`TodoWrite` tool	`task.md` artifacts
Visual brainstorming	Browser-based server	Native `generate_image` (no server needed)
Plan formatting	Plain markdown	Mermaid diagrams, file links, diff blocks, GitHub alerts
Background tasks	Not documented	`manage_task`, `send_message`, `schedule` (incl. cron)
UI verification	Not available	`browser-testing` skill with screenshot evidence
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)
Web research	Not guided	`search_web` + `read_url_content` integrated

Core Enhancements

Beyond the platform port, this fork adds capabilities that don't exist upstream:

🎨 generate_image in brainstorming — native mockup generation with carousel comparisons
📐 Rich plan formatting — Mermaid architecture diagrams, clickable file:/// links, diff blocks
🔄 Async subagent coordination — manage_task for builds, send_message mid-flight, schedule for timeouts
🌐 Browser-testing skill — evidence-before-assertions discipline for UI work
💰 Token-saving subagents — reviewers are read-only bundled agents
✅ Review gates — design docs wait for your partner's approval, and plans end with an ask_question your partner answers before work goes on
🔀 Workspace mode guidance — decision tables for branch and inherit per role; share is not recommended (semantics unverified)
🛡️ 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.
🔍 Web research integration — search_web woven into debugging, brainstorming, and planning

🚀 The Workflow

 ┌─────────────┐     ┌──────────────┐     ┌───────────────┐     ┌──────────────────────────┐
 │ Brainstorm  │ ──▶ │ Write Plan   │ ──▶ │ Create Branch │ ──▶ │ Subagent-Driven Dev      │
 │             │     │              │     │               │     │  ┌────────┐ ┌──────────┐ │
 │ • Questions │     │ • Tasks      │     │ • Isolated    │     │  │Implement│▶│  Review  │ │
 │ • Mockups   │     │ • Diagrams   │     │ • Clean base  │     │  └────────┘ └──────────┘ │
 │ • Design    │     │ • Specs      │     │ • Tests pass  │     │       ↺ per task         │
 └─────────────┘     └──────────────┘     └───────────────┘     └──────────────────────────┘
                                                                             │
                                                                             ▼
                                                                ┌──────────────────────────┐
                                                                │   Finish Branch          │
                                                                │  • Final review          │
                                                                │  • Merge / PR / Keep     │
                                                                └──────────────────────────┘

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
using-git-worktrees — Isolates the session on a feature branch; concurrent writing subagents get native Workspace: "branch"
writing-plans — Breaks work into bite-sized tasks with exact file paths and verification steps
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).
test-driven-development — RED-GREEN-REFACTOR: write failing test → minimal code → pass → commit
requesting-code-review — Reviews against plan, reports issues by severity
finishing-a-development-branch — Verifies tests, presents merge/PR/keep options

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.

Skills trigger automatically. Mandatory workflows, not suggestions.

🩺 When Something Goes Wrong

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>".

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.

You can also start it directly: /diagnosing-superpowers in the 2.0 app or /superpowers:diagnosing-superpowers in the CLI.

Running long plans

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.

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.
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.
- 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.
- IDE: add them to the terminal allowlist. Strict mode ignores it.
Don't use /goal: it skips the executors' stops and the finishing menu.

If a subagent's commit approval times out (60 seconds in the CLI), the controller makes the commit itself.

📦 Installation

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.

Antigravity 2.0 app and Antigravity IDE

Both discover plugins in the same folders, so one clone serves both. Install globally unless you want superpowers in chosen projects only.

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.

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)

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.

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 installation for the 2.0 app and the IDE (no git required)

Download ZIP instead of cloning (click to expand)

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.

Migrating a 2.0 app or 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

Troubleshooting

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.

Antigravity CLI (`agy`)

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

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):

git clone https://github.com/roundpilot/superpowers-antigravity <dir>
agy plugin install <dir>

Inside an agy session, /plugin install <local-path> does the same as agy plugin install <dir>.

List: agy plugin list
Update: run the same install command again. It replaces the installed copy, so any edits made inside the installed copy are lost.
Disable or enable: agy plugin disable superpowers / agy plugin enable superpowers
Uninstall: agy plugin uninstall superpowers (it also removes plugins.superpowers.enabled from ~/.gemini/config/config.json)

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.

✅ Verify Installation

Check the product's own view (no model turn):
- 2.0 app: Settings > Customizations lists superpowers under Plugins and its 16 skills under Skills.
- IDE: the … menu in the agent side panel > Customizations lists superpowers among the active plugin components, with its skills.
- CLI: agy plugin list shows superpowers and its components; agy -p "/skills" --output-format json lists the skills without starting an agent turn.
Slash command: type /using-superpowers in the 2.0 app or /superpowers:using-superpowers in the CLI. The bootstrap loads for the session.
Behaviour: say "Let's make a react todo list". The brainstorming skill should trigger and ask design questions instead of writing code.

🔌 Activation

Once installed, the methodology loads itself — no per-session setup:

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.
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.

The always-loaded footprint is a single ~55-line bootstrap; individual skills are read only when they trigger.

📚 Skills Reference

Testing & Verification

Skill	Purpose
test-driven-development	RED-GREEN-REFACTOR cycle with the `writing-good-tests` reference (falsifiability rules + mutation check)
browser-testing	Evidence-before-assertions for UI work (screenshot → DOM inspect → embed proof)

Debugging

Skill	Purpose
systematic-debugging	4-phase root cause process with `search_web` for unfamiliar errors
verification-before-completion	Ensure it's actually fixed; cron schedules for long test suites
diagnosing-superpowers	Work out what went wrong in a session, with evidence; export a scrubbed bundle or file an issue

Collaboration

Skill	Purpose
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
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
executing-plans	Inline plan execution: one context, one final review
dispatching-parallel-agents	Concurrent workflows with `Workspace: "branch"` / `"inherit"` and monitoring
requesting-code-review	Bundled `code-reviewer` (one task or a small range) and Pro-tier `final-reviewer` (whole branch), with severity classification
receiving-code-review	Responding to feedback with technical rigor
using-git-worktrees	Workspace isolation with mode decision table
finishing-a-development-branch	Merge/PR decision workflow
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

Bundled agents

Agent	Tier	Role
`implementer`	inherit	Implements one plan task in subagent-driven development, and fixes review findings
`implementer-flash`	flash	The same, for tasks whose plan gives the complete code and for single-file mechanical fixes
`implementer-pro`	pro	The same, for escalations and design work when your session runs below Pro
`spec-reviewer`	inherit	Read-only: checks one task's implementation against its task text
`code-reviewer`	inherit	Read-only: reviews code quality for one task or a small range
`re-reviewer`	inherit	Read-only: verifies a fix round
`final-reviewer`	pro	Read-only: reviews the whole branch before merge, for both executors
`session-analyst`	inherit	Read-only: analyses session transcripts for diagnosing-superpowers
`bundle-scrubber`	inherit	Redacts an exported diagnosis bundle for diagnosing-superpowers

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.

🧭 Philosophy

Test-Driven Development — Write tests first, always
Systematic over ad-hoc — Process over guessing
Complexity reduction — Simplicity as primary goal
Evidence over claims — Verify before declaring success

🤝 Contributing

See CONTRIBUTING.md for contribution guidelines, PR requirements, and quality standards.

📜 License

MIT License — see LICENSE for details.

🙏 Acknowledgements

This project is a fork of obra/superpowers. If Superpowers has helped you, consider sponsoring the original project.

Name		Name	Last commit message	Last commit date
.agents/skills/contributing-to-superpowers		.agents/skills/contributing-to-superpowers
.github		.github
agents		agents
assets		assets
docs		docs
hooks		hooks
rules		rules
skills		skills
tests		tests
.gitattributes		.gitattributes
.gitignore		.gitignore
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
RELEASE-NOTES.md		RELEASE-NOTES.md
package.json		package.json
plugin.json		plugin.json

Skill	Purpose
writing-skills	Create new skills following best practices
using-superpowers	Introduction to the skills system

Navigation Menu

Repository navigation

About

Repository files navigation

✨ How It Works

🔀 What's Different from Upstream?

Comparison Table

Core Enhancements

🚀 The Workflow

🩺 When Something Goes Wrong

Running long plans

📦 Installation

Antigravity 2.0 app and Antigravity IDE

macOS / Linux

Windows (PowerShell)

Windows (WSL)

Manual installation for the 2.0 app and the IDE (no git required)

Migrating a 2.0 app or IDE install from `roundpilot/superpowers`

Troubleshooting

Antigravity CLI (`agy`)

✅ Verify Installation

🔌 Activation

📚 Skills Reference

Testing & Verification

Debugging

Collaboration

Meta

Bundled agents

🧭 Philosophy

🤝 Contributing

📜 License

🙏 Acknowledgements

About

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

✨ How It Works

🔀 What's Different from Upstream?

Comparison Table

Core Enhancements

🚀 The Workflow

🩺 When Something Goes Wrong

Running long plans

📦 Installation

Antigravity 2.0 app and Antigravity IDE

macOS / Linux

Windows (PowerShell)

Windows (WSL)

Manual installation for the 2.0 app and the IDE (no git required)

Migrating a 2.0 app or IDE install from roundpilot/superpowers

Troubleshooting

Antigravity CLI (agy)

✅ Verify Installation

🔌 Activation

📚 Skills Reference

Testing & Verification

Debugging

Collaboration

Meta

Bundled agents

🧭 Philosophy

🤝 Contributing

📜 License

🙏 Acknowledgements

About

Topics

Resources

Code of conduct

Contributing

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

Migrating a 2.0 app or IDE install from `roundpilot/superpowers`

Antigravity CLI (`agy`)