@tsubus/pi-superpowers7.0.1-pi.1

Superpowers for Pi

Superpowers is a complete software development methodology for your coding agent, built on composable skills and initial instructions that make sure the agent uses them.

This package brings upstream Superpowers to Pi through npm. It includes the unchanged upstream Pi extension and complete skills, so you can install it without direct access to GitHub.

Table of Contents

• How it works
• Installation
• Using Superpowers
• The Basic Workflow
• When Something Goes Wrong
• What's Inside
• Philosophy
• Community
• Contributing
• Updating
• License
• Visual companion telemetry

How it works

It starts from the moment you fire up Pi. As soon as it sees that you're building something, it doesn't just jump into writing code. Instead, it steps back and asks what you're really trying to do.

Once it's teased a spec out of the conversation, it shows its understanding in chunks short enough to read and digest. After you've signed off on the design, it puts together a detailed implementation plan. The process emphasizes red/green TDD, YAGNI (You Aren't Gonna Need It), and DRY.

Next, once you say "go", Pi works through each engineering task, checking and reviewing its work against the plan. With an optional subagent tool installed, it can delegate tasks to fresh agents and review their work. Without one, it implements the plan in the current session.

Because skills trigger when relevant, you don't need to do anything special. Pi just has Superpowers.

Installation

Install the Pi package from npm:

pi install npm:@tsubus/pi-superpowers

Restart Pi after installation. Node.js >=22.19 and a compatible Pi installation are required.

The package contains the extension, skills and supporting files. It has no install-time GitHub downloads or runtime npm dependencies, so your usual npm registry/proxy configuration can be used in environments that block GitHub.

Replacing an existing installation

If you already installed Superpowers from git, remove that package first to avoid duplicate skills and bootstrap instructions:

pi remove git:github.com/obra/superpowers
pi install npm:@tsubus/pi-superpowers

If your original source differs, use the source shown by pi list in the remove command.

Using Superpowers

Start Pi in your project and describe what you want to build or fix. For example:

Let's design and build a todo list for this project.

A working installation should start with brainstorming before writing feature code. For a bug, describe the unexpected behavior and ask Pi to investigate it systematically.

The extension loads the Superpowers skills and injects the using-superpowers bootstrap at session startup and again after compaction. Pi's native skill system loads the relevant instructions as work progresses. To explicitly invoke a skill, use its Pi command:

/skill:brainstorming
/skill:systematic-debugging
/skill:writing-plans

Subagent and task-list tools are optional Pi companion packages, not bundled with Superpowers. For example, an installed pi-subagents tool enables delegated workflows. Without these tools, Pi can execute plans itself and track tasks in plan files instead.

The Basic Workflow

1. brainstorming — Before building, draws out what you actually want and why. Plays its understanding back for correction, explores approaches and gets approval of the design before implementation.
2. using-git-worktrees — After design approval, helps arrange an isolated workspace and verify a clean baseline, with your consent.
3. writing-plans — Breaks the approved design into bite-sized tasks with exact file paths and verification steps.
4. subagent-driven-development or executing-plans — Works through the plan using fresh subagents and per-task reviews when available, or implements it directly in the current session with a final review.
5. test-driven-development — Enforces RED-GREEN-REFACTOR: write a failing test, watch it fail, write the minimum code, then verify it passes.
6. requesting-code-review — Reviews against the plan, reports issues by severity and addresses critical problems before progressing.
7. finishing-a-development-branch — Verifies tests and presents integration options such as merging, pushing for review or keeping the branch as-is.

Pi checks for relevant skills before a task. These are workflows to follow, not just suggestions.

When Something Goes Wrong

If a skill stays silent, fires at the wrong time, ignores the plan, repeats work or uses more tokens than expected, ask Pi:

Figure out what went wrong with Superpowers in this session.

It can invoke diagnosing-superpowers to inspect the session transcript and report what happened with evidence. To investigate an earlier session, include its session ID or path. If requested, the skill can prepare a scrubbed bug-report bundle.

What's Inside

Testing

• test-driven-development — RED-GREEN-REFACTOR, including testing anti-patterns.

Debugging

• systematic-debugging — Four-phase root-cause investigation, including root-cause tracing, defense-in-depth and condition-based waiting.
• verification-before-completion — Verify a fix before declaring success.
• diagnosing-superpowers — Investigate session failures with evidence.

Collaboration

• brainstorming — Draw out intent before building.
• writing-plans — Detailed implementation plans.
• executing-plans — Direct plan execution in the current session.
• dispatching-parallel-agents — Independent concurrent subagent workflows.
• requesting-code-review — Review work against requirements.
• receiving-code-review — Evaluate and act on feedback.
• using-git-worktrees — Isolated development workspaces.
• finishing-a-development-branch — Integration and branch-finishing decisions.
• subagent-driven-development — Task-by-task implementation and review.

Meta

• writing-skills — Create and test new skills.
• using-superpowers — Introduction to the skills system.

Philosophy

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

Read the original release announcement.

Community

Superpowers is built by Jesse Vincent and the team at Prime Radiant. This npm package is a Pi-focused redistribution, not a separate implementation of the skills.

• Discord: Upstream community.
• Skill and workflow issues: Upstream issues.
• npm package issues: Package issues.
• Release announcements: Upstream mailing list.

Contributing

For changes to skills and workflow behavior, follow the upstream contribution guidelines and the writing-skills skill.

Package maintenance is documented separately in MAINTAINING.md.

Updating

Update installed Pi packages with:

pi update --extensions

Restart Pi after updating. This package follows upstream stable release versions; new versions become available after the scheduled upstream check succeeds.

License

MIT. See LICENSE and the upstream license. The distributed package also includes the original upstream license.

Visual companion telemetry

Upstream brainstorming includes an optional visual companion. By default, its Prime Radiant logo is loaded from the upstream website with the Superpowers version. According to upstream, it does not include project, prompt or agent details, clicks or information about what you're building.

To disable this telemetry, set SUPERPOWERS_DISABLE_TELEMETRY to a true value before starting Pi:

SUPERPOWERS_DISABLE_TELEMETRY=1 pi