@complexthings/superpowers-agent 9.2.0 → 10.0.0

package/README.md

@@ -2,10 +2,27 @@
 
 A comprehensive skills library of proven techniques, patterns, and workflows for AI coding assistants.
 
-**This is a fork and extension of Jesse Vincent's incredible [Superpowers for Claude Code](https://github.com/obra/superpowers).** Jesse's groundbreaking work and [his amazing blog post](https://blog.fsck.com/2025/10/09/superpowers/) introduced the concept of systematic, reusable skills for AI agents. This fork extends that vision to support agent-agnostic workflows across GitHub Copilot, Claude Code, and OpenCode.
+**This is a fork and extension of Jesse Vincent's incredible [Superpowers for Claude Code](https://github.com/obra/superpowers).** Jesse's groundbreaking work and [his amazing blog post](https://blog.fsck.com/2025/10/09/superpowers/) introduced the concept of systematic, reusable skills for AI agents. This fork extends that vision to support agent-agnostic workflows across GitHub Copilot, Claude Code, OpenCode, Pi, and OpenAI Codex.
 
 ## What's New
 
+**v10.0.0 (July 12, 2026):**
+
+- ⚠️ **Leaner bundled surface** — most bundled skills were retired. The package now ships only four: `brainstorming`, `leveraging-cli-tools`, `create-skill-json`, and `setup-skills`. Install anything else with `superpowers-agent add`.
+- ⚠️ **Retired CLI commands removed** — the skill discovery/execution commands `dir`, `execute`, `find-skills`, `get-helpers`, `path`, and `use-skill` are gone. Skills are discovered and loaded through each harness's native skill tool, not the CLI.
+- ⚠️ **`brainstorming` deprecated** — it now announces its deprecation and redirects to the `grilling` skill, handing over the same context.
+- **Pi & OpenAI Codex supported** — `superpowers-agent` now detects and targets **Pi** (`.pi`) and **OpenAI Codex** (`.codex`) alongside GitHub Copilot, Claude Code, and OpenCode — five supported harnesses. Detection works whether a harness is installed as a binary or a project folder.
+- **RTK + ponytail integration** — `setup-rtk.sh` (harness-aware RTK config) and `setup-ponytail.sh` wire token-optimized CLI output and minimal-solution guidance into each harness. `leveraging-cli-tools` was rewritten around `rtk` and `ponytail`, with RTK Python guidance.
+- **`SUPERPOWERS.md` linked** from generated `AGENTS.md`, `CLAUDE.md`, and `copilot-instructions.md`; `setup-skills` dedupes the backups it creates and replaces the `copilot-instructions.md` marker idempotently.
+
+**v9.2.1 (June 1, 2026):**
+
+- **GitHub agents now reach the Copilot CLI** — `add` and `pull` now also symlink GitHub agents (`.github/agents/<name>.agent.md`) into `~/.copilot/agents/`, alongside the existing VS Code `prompts/` install, so the same agents are usable by the GitHub Copilot CLI. `rm` cleans up both locations.
+- **npm-based version monitoring** — the `using-superpowers` skill and `AGENTS.md` template now check for updates by querying the npm registry (`npm view @complexthings/superpowers-agent version`) and comparing by semver precedence, prompting you to update only when npm is actually newer (replaces the old bundled-version-string comparison).
+- **Smarter skill-priority guidance** — `using-superpowers` now tells agents to load domain/context skills first, then process skills (brainstorming, planning, debugging, TDD), then implementation skills, so the domain skill can shape which process fits.
+- **`leveraging-cli-tools` nudge broadened** — the session-start context now also points agents at the skill whenever a task involves using Bash.
+- **Template cleanup** — removed `TOOLS.md.template` and the `{{TOOL_MAPPINGS}}` bootstrap placeholder; tool-equivalence guidance now lives inline in the refreshed `AGENTS.md`/`SUPERPOWERS.md` templates. `AGENTS.md` skill priority simplified to Project → Personal.
+
 **v9.1.0 (May 30, 2026):**
 
 - **Session-start hooks installed by `bootstrap`** — `bootstrap` now installs a Claude Code `SessionStart` hook into `~/.claude/settings.json` and a GitHub Copilot CLI `sessionStart` hook at `~/.copilot/hooks/superpowers.json`, so the Superpowers context is injected at the start of every session. The Claude merge is idempotent and preserves your other hooks/settings. (This replaces the old Claude Code plugin hook, which has been removed.)
@@ -51,48 +68,23 @@ A comprehensive skills library of proven techniques, patterns, and workflows for
 - 📋 **Smart Copilot Instructions** - `bootstrap` and `update` now process `~/.github/copilot-instructions.md` as a template, injecting the `using-superpowers` skill content and supporting marker-based idempotent updates with automatic backups
 - 📊 **Mermaid Flowcharts** - Replaced DOT-format flowcharts with Mermaid syntax across 8 skills for better rendering in GitHub, VS Code, and agent contexts
 
-**v6.5.0 (January 24, 2026):**
-
-- 🔄 **Upstream Sync** - Ported advanced features from Jesse Vincent's [obra/superpowers](https://github.com/obra/superpowers) v4.1.1:
-  - **OpenCode Plugin** (`.opencode/plugins/superpowers-agent.js`) - Session bootstrap injection via system prompt transform
-  - **using-superpowers Skill** - Behavioral enforcement with Red Flags rationalization table (12 anti-patterns)
-  - **Two-Stage Code Review** - Spec compliance review + code quality review workflow
-  - **Test Infrastructure** (`tests/`) - Agent-agnostic test scripts for skill triggering
-
-- 🔌 **OpenCode Plugin** - Native plugin for OpenCode that injects superpowers context at every session start using `experimental.chat.system.transform` hook
-
-- 📋 **Two-Stage Review Process** - Updated `subagent-driven-development` skill with spec reviewer and code quality reviewer prompts for comprehensive code review
-
-**v6.4.x (January 23-24, 2026):**
-
-- 📐 **Context Optimization** - Reduced AGENTS.md context size by ~60-70% with separate SUPERPOWERS.md reference file
-- 🔗 **Project-Level Symlinks** - `setup-skills` now creates symlinks from agent directories to `.agents/skills`
-
-**Previous Releases:**
-
-- **v6.3.x** - Codex platform support, native skill tools, extended symlinks for OpenCode/Cursor/Gemini
-- **v6.0.0** - Complete codebase modernization with 90% bundle reduction
-- **v5.4.0** - Dynamic tool mappings, automated platform detection
-
 **Key Features:**
 
-- 🎯 **Smart Skill Matching** - Just type `superpowers execute brainstorming` instead of full paths
+- 🎯 **Native Skill Discovery** - Your AI platform discovers and loads skills directly
 - 🚀 **One-Line Installer** - `npm install -g @complexthings/superpowers-agent`
 - 📦 **Skill Installation** - `add` and `add-repository` commands for Git/local skill installation
-- 🔍 **Helper Discovery** - `get-helpers` finds scripts within skills using substring matching
-- 📝 **Setup Skills** - `setup-skills` skill initializes projects with agent instruction files and skill symlinks
+- 📝 **Setup Skills** - `setup-skills` initializes projects with agent instruction files and skill symlinks
 
 ## What You Get
 
-- **Testing Skills** - TDD, async testing, anti-patterns
-- **Debugging Skills** - Systematic debugging, root cause tracing, verification
-- **Collaboration Skills** - Brainstorming, planning, code review, parallel agents
-- **Development Skills** - Git worktrees, finishing branches, subagent workflows
-- **Meta Skills** - Creating, testing, and sharing skills
-- **Utility Commands** - `find-skills` to discover available skills, `execute` to load them
+- **Requirement Grilling** - Interrogate a plan into a clear, reviewed design (the `grilling` skill; `brainstorming` now redirects here)
+- **Efficient CLI Workflows** - Search, inspect, and shape command output with less noise
+- **Skill Metadata** - Generate consistent `skill.json` files from existing skills
+- **Skill Setup** - Initialize project skill infrastructure
+- **Native Skill Tools** - Skills are discovered and loaded by your AI platform
 
 Plus:
-- **Universal Skills** - Work across GitHub Copilot, Claude Code, and OpenCode
+- **Universal Skills** - Work across GitHub Copilot, Claude Code, OpenCode, Pi, and OpenAI Codex
 - **Automatic Integration** - Skills activate automatically when relevant
 - **Consistent Workflows** - Systematic approaches to common engineering tasks
 
@@ -109,7 +101,7 @@ superpowers-agent bootstrap
 
 > **Note:** `superpowers-agent bootstrap` is a **required** one-time step after every fresh install. It is no longer run automatically by npm's `postinstall` hook — you must run it manually. Subsequent `superpowers-agent update` calls will run bootstrap for you automatically.
 
-## Migration to Superpower Agent `^8.0.0`
+## Migration to Superpower Agent `^10.0.0`
 
 ```bash
 rm -rf ~/.local/bin/superpowers-agent ~/.local/bin/superpowers ~/.agents/superpowers
@@ -117,12 +109,9 @@ npm install -g @complexthings/superpowers-agent
 superpowers-agent bootstrap
 ```
 
-**After installation, you can use Superpowers from anywhere:**
-```bash
-superpowers --help
-superpowers find-skills
-superpowers execute systematic-debugging
-```
+**After installation, your AI platform can discover Superpowers skills automatically.**
+
+If your platform has no native skill tool, open the relevant `SKILL.md` from its configured skill directories with your file-read tool.
 
 ## Manual Installation
 
@@ -132,40 +121,19 @@ If you prefer manual installation or need project-specific setup, see [.agents/I
 
 ## Quick Start
 
-### Discovering Skills
-
-**List all available skills:**
-```bash
-superpowers find-skills
-```
-
-**Search for specific skills:**
-```bash
-superpowers find-skills | grep -i <topic>
-```
+### Discovering and Using Skills
 
-### Using Skills
-
-**Smart skill matching** - Just type the skill name or any suffix:
-```bash
-superpowers execute brainstorming              # Finds superpowers:collaboration/brainstorming
-superpowers execute test-driven-development    # Finds superpowers:testing/test-driven-development
-superpowers execute collaboration/brainstorming # More specific suffix also works
-```
-
-**Full paths still work:**
-```bash
-superpowers execute superpowers:collaboration/brainstorming
-```
+Use your AI platform's native skill tool to view available skills and load the one relevant to your task. If no native skill tool is available, inspect the configured project or personal skill directories and open the relevant `SKILL.md` with your file-read tool.
 
 **Priority order:** Project skills → Home skills → Global Superpowers skills
 
-### Automatic Skill Activation
+### Bundled Skills
 
-Skills activate automatically when relevant. For example:
-- `test-driven-development` activates when implementing features
-- `systematic-debugging` activates when debugging issues
-- `verification-before-completion` activates before claiming work is done
+This release bundles four skills:
+- `brainstorming` — **deprecated**; redirects to the `grilling` skill
+- `leveraging-cli-tools`
+- `create-skill-json`
+- `setup-skills`
 
 ## Configuration
 
@@ -202,8 +170,7 @@ Superpowers supports project-level and global configuration via `.agents/config.
 
 **Read config from CLI:**
 ```bash
-superpowers-agent get-config prompts_dir
-superpowers-agent get-config plans_dir
+superpowers-agent config-get   # prints the resolved configuration, including prompts_dir and plans_dir
 ```
 
 ### Repository Aliases
@@ -272,8 +239,9 @@ Repositories can include an `agents.json` manifest to automatically install AI a
 
 | Platform | Source Directory | Destination |
 |----------|----------------|-------------|
-| `github` | `.github/agents/<name>.agent.md` | VS Code `prompts/` directory |
+| `github` | `.github/agents/<name>.agent.md` | VS Code `prompts/` directory **and** `~/.copilot/agents/` (GitHub Copilot CLI) |
 | `opencode` | `.opencode/agents/<name>.md` | `~/.config/opencode/agents/` |
+| `claude` | `.claude/agents/<name>.md` | `~/.claude/agents/` |
 
 **How it works:**
 1. After skills are installed, the system checks for `agents.json` at the repository root
@@ -325,97 +293,23 @@ Skills are available via the native skill tool. `bootstrap` installs a `sessionS
 
 Skills are available via the native skill tool. Claude agent personas defined in `.claude/agents/<name>.md` are installed into `~/.claude/agents/` via `add`/`pull`. `bootstrap` also installs a `SessionStart` hook into `~/.claude/settings.json` that injects the Superpowers context every session (idempotent; preserves your other hooks and settings).
 
-## What's Inside
-
-### Skills Library
-
-**Testing** (`skills/testing/`)
-- **test-driven-development** - RED-GREEN-REFACTOR cycle
-- **condition-based-waiting** - Async test patterns
-- **testing-anti-patterns** - Common pitfalls to avoid
-- **verification-before-completion** - Evidence-based completion claims (ported from obra/superpowers)
-
-**Debugging** (`skills/debugging/`)
-- **systematic-debugging** - 4-phase root cause process
-- **root-cause-tracing** - Find the real problem
-- **defense-in-depth** - Multiple validation layers
-
-**Collaboration** (`skills/collaboration/`)
-- **brainstorming** - Socratic design refinement
-- **writing-plans** - Detailed implementation plans
-- **executing-plans** - Batch execution with checkpoints
-- **dispatching-parallel-agents** - Concurrent subagent workflows
-- **requesting-code-review** - Pre-review checklist
-- **receiving-code-review** - Responding to feedback
-- **using-git-worktrees** - Parallel development branches
-- **finishing-a-development-branch** - Merge/PR decision workflow
-- **subagent-driven-development** - Fast iteration with two-stage code review (spec + quality)
-- **leveraging-cli-tools** - High-performance CLI tools (rg, jq, fd, bat, ast-grep)
-
-**Meta** (`skills/meta/`)
-- **using-superpowers** - Behavioral enforcement skill loaded at session start (ported from obra/superpowers)
-- **writing-prompts** - Create custom slash commands for GitHub Copilot, Cursor, or Claude
-- **creating-prompts** - Create structured prompts for Do/Plan/Research/Refine workflows (adapted from TÂCHES)
-- **create-skill-json** - Generate skill.json metadata files from SKILL.md and directory structure
-
-**Utilities** (`skills/finding-skills/`, `skills/using-a-skill/`, `skills/setup-skills/`)
-- **finding-skills** - Discover and search available skills
-- **using-a-skill** - Load and apply specific skills
-- **setup-skills** - Initialize project with agent instruction files and skill symlinks
-
-**Problem-Solving** (`skills/problem-solving/`)
-- **collision-zone-thinking** - Force unrelated concepts together for emergent insights
-- **inversion-exercise** - Flip assumptions to reveal hidden constraints
-- **meta-pattern-recognition** - Spot universal principles across domains
-- **scale-game** - Test at extremes to expose fundamental truths
-- **simplification-cascades** - Find insights that eliminate multiple components
-- **when-stuck** - Dispatch to right problem-solving technique
-
-**Research** (`skills/research/`)
-- **tracing-knowledge-lineages** - Understand how ideas evolved over time
-
-**Architecture** (`skills/architecture/`)
-- **preserving-productive-tensions** - Keep multiple valid approaches instead of forcing premature resolution
-
-### Test Infrastructure
-
-The `tests/` directory contains agent-agnostic test scripts for validating skill behavior:
-
-**Test Categories:**
-- `tests/skill-triggering/` - Tests for implicit skill activation scenarios
-- `tests/explicit-skill-requests/` - Tests for explicit skill loading requests
-
-**Running Tests:**
-```bash
-# Run a single test
-./tests/skill-triggering/run-test.sh prompts/test-name.txt
-
-# Run all tests in a category
-./tests/skill-triggering/run-all.sh
-
-# Configure for your agent
-export AGENT_CLI="opencode"  # or "claude", "copilot", etc.
-./tests/skill-triggering/run-test.sh prompts/test-name.txt
-```
+## Bundled Skills
 
-**Creating New Tests:**
-1. Add prompt files to `prompts/` subdirectory
-2. Each test is a `.txt` file with the prompt to send
-3. Scripts output agent responses for manual verification
+The package contains only the four skills listed in [Quick Start](#quick-start). Install additional skills with `superpowers-agent add`.
 
-### CLI Commands
+### Running Tests
 
-The `superpowers-agent` CLI provides powerful commands for managing skills:
+Run the automated suite from `.agents`:
 
-**Skill Discovery:**
 ```bash
-superpowers-agent find-skills              # List all available skills
-superpowers-agent execute <name>           # Load a specific skill
-superpowers-agent path <skill-name>        # Get SKILL.md file path
-superpowers-agent dir <skill-name>         # Get skill directory path
-superpowers-agent get-helpers <skill> <term>  # Find helper files in skill
+cd .agents
+bun test
 ```
 
+### CLI Commands
+
+The `superpowers-agent` CLI provides commands for managing installed skills. Skill discovery and loading use your AI platform's native skill tool.
+
 **Skill Installation:**
 ```bash
 superpowers-agent add <url-or-path>        # Install skill(s) from Git or local
@@ -433,7 +327,6 @@ superpowers-agent add-repository <git-url> # Add repository alias
 ```bash
 superpowers-agent config-get               # Show current configuration
 superpowers-agent config-set <key> <value> # Update configuration
-superpowers-agent get-config <key>         # Get specific config value
 ```
 
 **Project Setup:**
@@ -449,54 +342,29 @@ superpowers-agent session-context                    # Print session-start conte
 superpowers-agent session-context --format=claude    # Emit Claude Code SessionStart hook JSON
 superpowers-agent session-context --format=copilot   # Emit GitHub Copilot sessionStart hook JSON
 ```
-The platform hooks installed by `bootstrap` call this command; it is the single source of truth for the injected prompt (the `using-superpowers` content plus the `leveraging-cli-tools` directive).
+The platform hooks installed by `bootstrap` call this command; it is the single source of truth for the injected CLI-tool nudge.
 
 ### Skill Metadata with skill.json
 
-Skills can include a `skill.json` file to define metadata for the superpowers-agent CLI. This enables powerful features like repository aliases, helper file discovery, and multi-skill repositories.
-
-**All skills in this repository include skill.json files** with version tracking, helper file listings, and aliases for convenient access.
+Skills can include a `skill.json` file to define installation metadata for the superpowers-agent CLI and multi-skill repositories.
 
 #### Single Skill Configuration
 
-For a single skill, `skill.json` defines the skill's identity and helpers:
+For a single skill, `skill.json` defines its identity:
 
 ```json
 {
   "version": "1.0.0",
   "name": "aem/block-collection-and-party",
-  "title": "AEM Block Collection and Party",
-  "helpers": [
-    "scripts/get-block-structure.js",
-    "scripts/search-block-collection-github.js",
-    "scripts/search-block-collection.js",
-    "scripts/search-block-party.js"
-  ],
-  "aliases": [
-    "block-party",
-    "block-collection"
-  ]
+  "title": "AEM Block Collection and Party"
 }
 ```
 
 **Fields:**
 - `name`: Canonical skill name (used for installation path)
 - `title`: Human-readable display name
-- `helpers`: Array of helper script paths relative to skill directory
-- `aliases`: Short names that can be used with `execute` and `get-helpers`
 - `version`: Skill version for tracking updates
 
-**Usage with helpers:**
-```bash
-# Find helper files
-superpowers-agent get-helpers block-collection search-block
-# Returns: /path/to/skill/scripts/search-block-collection.js
-
-# Use skill aliases
-superpowers-agent execute block-party
-# Loads: aem/block-collection-and-party
-```
-
 #### Multi-Skill Repository Configuration
 
 For repositories containing multiple skills, the root `skill.json` lists all skills and defines a repository alias:
@@ -548,12 +416,10 @@ superpowers-agent add @baici
 
 #### Benefits of skill.json
 
-1. **Helper Discovery**: Find and execute helper scripts easily
-2. **Skill Aliases**: Use short, memorable names instead of full paths
-3. **Repository Management**: Organize and share multi-skill collections
-4. **Automatic Detection**: CLI reads metadata for smart defaults
-5. **Installation Paths**: Control where skills install with `name` field
-6. **Version Tracking**: Each skill tracks its version independently
+1. **Repository Management**: Organize and share multi-skill collections
+2. **Automatic Detection**: CLI reads metadata for installation defaults
+3. **Installation Paths**: Control where skills install with `name` field
+4. **Version Tracking**: Each skill tracks its version independently
 
 ## How It Works
 
@@ -561,7 +427,7 @@ superpowers-agent add @baici
 1. **Bootstrap Process** - Installs agent integrations and syncs skill symlinks globally
 2. **Skill Discovery** - Finds skills across system, personal, and project locations
 3. **Priority Resolution** - Project skills override personal skills override system skills
-4. **Universal Integration** - Works with GitHub Copilot, Claude Code, and OpenCode
+4. **Universal Integration** - Works with GitHub Copilot, Claude Code, OpenCode, Pi, and OpenAI Codex
 
 **For OpenCode:**
 1. **Plugin System** - The `.opencode/plugins/superpowers-agent.js` plugin injects bootstrap context dynamically at session start
@@ -671,13 +537,12 @@ Configuration is stored in `~/.agents/superpowers/.config.json` and persists acr
 
 This project builds on [Jesse Vincent's Superpowers for Claude Code](https://github.com/obra/superpowers). Jesse's pioneering work introduced the concept of systematic, reusable skills for AI agents. Read his excellent blog post: [Superpowers for Claude Code](https://blog.fsck.com/2025/10/09/superpowers/)
 
-**Ported from obra/superpowers (v7.0.0):**
-- `using-superpowers` behavioral enforcement skill
-- Two-stage code review process (spec + quality reviewers)
+**Inspired by obra/superpowers (v7.0.0):**
+- Reusable skill workflows
 - OpenCode plugin architecture pattern
 - Test infrastructure for skill validation
 
-This fork extends that vision to support agent-agnostic workflows across GitHub Copilot, Claude Code, and OpenCode.
+This fork extends that vision to support agent-agnostic workflows across GitHub Copilot, Claude Code, OpenCode, Pi, and OpenAI Codex.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@complexthings/superpowers-agent",
-  "version": "9.2.0",
+  "version": "10.0.0",
   "description": "Superpowers agent CLI — skills system for AI coding agents",
   "type": "module",
   "bin": {

package/skills/collaboration/brainstorming/SKILL.md

@@ -1,166 +1,66 @@
 ---
 name: brainstorming
-description: "You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation."
+description: "DEPRECATED — redirects to the grilling skill. Fires before any creative work — creating features, building components, adding functionality, or modifying behavior — to tell the user brainstorming is retired, offer to install grilling, and hand the same context to a grilling session."
 ---
 
-# Brainstorming Ideas Into Designs
-
-Help turn ideas into fully formed designs and specs through natural collaborative dialogue.
-
-Start by understanding the current project context, then ask questions one at a time to refine the idea. Once you understand what you're building, present the design and get user approval.
-
-<HARD-GATE>
-Do NOT invoke any implementation skill, write any code, scaffold any project, or take any implementation action until you have presented a design and the user has approved it. This applies to EVERY project regardless of perceived simplicity.
-</HARD-GATE>
-
-## Anti-Pattern: "This Is Too Simple To Need A Design"
-
-Every project goes through this process. A todo list, a single-function utility, a config change — all of them. "Simple" projects are where unexamined assumptions cause the most wasted work. The design can be short (a few sentences for truly simple projects), but you MUST present it and get approval.
-
-## Checklist
-
-You MUST create a task for each of these items and complete them in order:
-
-1. **Explore project context** — check files, docs, recent commits
-2. **Offer visual companion** (if topic will involve visual questions) — this is its own message, not combined with a clarifying question. See the Visual Companion section below.
-3. **Ask clarifying questions** — one at a time, understand purpose/constraints/success criteria
-4. **Propose 2-3 approaches** — with trade-offs and your recommendation
-5. **Present design** — in sections scaled to their complexity, get user approval after each section
-6. **Write design doc** — save to `docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md` and commit
-7. **Spec review loop** — dispatch spec-document-reviewer subagent with precisely crafted review context (never your session history); fix issues and re-dispatch until approved (max 5 iterations, then surface to human)
-8. **User reviews written spec** — ask user to review the spec file before proceeding
-9. **Transition to implementation** — invoke writing-plans skill to create implementation plan
-
-## Process Flow
-
-```dot
-digraph brainstorming {
-    "Explore project context" [shape=box];
-    "Visual questions ahead?" [shape=diamond];
-    "Offer Visual Companion\n(own message, no other content)" [shape=box];
-    "Ask clarifying questions" [shape=box];
-    "Propose 2-3 approaches" [shape=box];
-    "Present design sections" [shape=box];
-    "User approves design?" [shape=diamond];
-    "Write design doc" [shape=box];
-    "Spec review loop" [shape=box];
-    "Spec review passed?" [shape=diamond];
-    "User reviews spec?" [shape=diamond];
-    "Invoke writing-plans skill" [shape=doublecircle];
-
-    "Explore project context" -> "Visual questions ahead?";
-    "Visual questions ahead?" -> "Offer Visual Companion\n(own message, no other content)" [label="yes"];
-    "Visual questions ahead?" -> "Ask clarifying questions" [label="no"];
-    "Offer Visual Companion\n(own message, no other content)" -> "Ask clarifying questions";
-    "Ask clarifying questions" -> "Propose 2-3 approaches";
-    "Propose 2-3 approaches" -> "Present design sections";
-    "Present design sections" -> "User approves design?";
-    "User approves design?" -> "Present design sections" [label="no, revise"];
-    "User approves design?" -> "Write design doc" [label="yes"];
-    "Write design doc" -> "Spec review loop";
-    "Spec review loop" -> "Spec review passed?";
-    "Spec review passed?" -> "Spec review loop" [label="issues found,\nfix and re-dispatch"];
-    "Spec review passed?" -> "User reviews spec?" [label="approved"];
-    "User reviews spec?" -> "Write design doc" [label="changes requested"];
-    "User reviews spec?" -> "Invoke writing-plans skill" [label="approved"];
-}
-```
-
-**The terminal state is invoking writing-plans.** Do NOT invoke frontend-design, mcp-builder, or any other implementation skill. The ONLY skill you invoke after brainstorming is writing-plans.
-
-## The Process
-
-**Understanding the idea:**
-
-- Check out the current project state first (files, docs, recent commits)
-- Before asking detailed questions, assess scope: if the request describes multiple independent subsystems (e.g., "build a platform with chat, file storage, billing, and analytics"), flag this immediately. Don't spend questions refining details of a project that needs to be decomposed first.
-- If the project is too large for a single spec, help the user decompose into sub-projects: what are the independent pieces, how do they relate, what order should they be built? Then brainstorm the first sub-project through the normal design flow. Each sub-project gets its own spec → plan → implementation cycle.
-- For appropriately-scoped projects, ask questions one at a time to refine the idea
-- Prefer multiple choice questions when possible, but open-ended is fine too
-- Only one question per message — if a topic needs more exploration, break it into multiple questions
-- Focus on understanding: purpose, constraints, success criteria
-
-**Exploring approaches:**
-
-- Propose 2-3 different approaches with trade-offs
-- Present options conversationally with your recommendation and reasoning
-- Lead with your recommended option and explain why
-
-**Presenting the design:**
+# Brainstorming (deprecated)
 
-- Once you believe you understand what you're building, present the design
-- Scale each section to its complexity: a few sentences if straightforward, up to 200-300 words if nuanced
-- Ask after each section whether it looks right so far
-- Cover: architecture, components, data flow, error handling, testing
-- Be ready to go back and clarify if something doesn't make sense
+This skill is deprecated. It no longer explores requirements itself — it redirects to Matt Pocock's `grilling` skill, which does the same job better by interviewing the user one decision at a time.
 
-**Design for isolation and clarity:**
+Run these steps in order. The user's original request (the context that triggered this skill) is what you hand to `grilling` at the end — keep it.
 
-- Break the system into smaller units that each have one clear purpose, communicate through well-defined interfaces, and can be understood and tested independently
-- For each unit, you should be able to answer: what does it do, how do you use it, and what does it depend on?
-- Can someone understand what a unit does without reading its internals? Can you change the internals without breaking consumers? If not, the boundaries need work.
-- Smaller, well-bounded units are also easier to work with — you reason better about code you can hold in context at once, and edits are more reliable when files are focused. When a file grows large, that's often a signal that it's doing too much.
+## 1. Tell the user it's deprecated
 
-**Working in existing codebases:**
+Say, in your own words: the `brainstorming` skill is deprecated and they should use `grilling` instead.
 
-- Explore the current structure before proposing changes. Follow existing patterns.
-- Where existing code has problems that affect the work (e.g., a file that's grown too large, unclear boundaries, tangled responsibilities), include targeted improvements as part of the design — the way a good developer improves code they're working in.
-- Don't propose unrelated refactoring. Stay focused on what serves the current goal.
+## 2. Offer to install grilling
 
-## After the Design
+Using your question-asking tool (`askUserQuestion`, `ask_user_question`, `AskUserQuestion`, `question`, or equivalent), ask whether they want the `grilling` skill installed now.
 
-**Documentation:**
+If they decline, skip to step 5 and run the grilling interview yourself using the instructions in this file's spirit — but grilling works best installed, so recommend it.
 
-- Write the validated design (spec) to `docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md`
-  - (User preferences for spec location override this default)
-- Use elements-of-style:writing-clearly-and-concisely skill if available
-- Commit the design document to git
+## 3. Check whether grilling is already installed
 
-**Spec Review Loop:**
+Look for an existing `grilling/SKILL.md` in the project and in these system locations:
 
-After writing the spec document:
+- `~/.agents/skills/grilling/SKILL.md`
+- `~/.claude/skills/grilling/SKILL.md`
+- `~/.github/skills/grilling/SKILL.md`
+- `~/.pi/skills/grilling/SKILL.md`
+- `~/.opencode/skill/grilling/SKILL.md` (the missing trailing `s` on `skill` is correct)
 
-1. Dispatch spec-document-reviewer subagent (see `spec-document-reviewer-prompt.md`)
-2. If issues found: fix, re-dispatch, repeat until approved
-3. If loop exceeds 5 iterations, surface to human for guidance
+If found anywhere, **skip the install** (step 4). Tell the user they already have it. Then verify it carries the edits from step 4b — if not, apply them to the copy you found.
 
-**User Review Gate:**
+## 4. Install grilling (only if not already installed)
 
-After the spec review loop passes, ask the user to review the written spec before proceeding:
+Run this in the **project root**, appending the `--agent` flag for your current agent:
 
-> "Spec written and committed to `<path>`. Please review it and let me know if you want to make any changes before we start writing out the implementation plan."
-
-Wait for the user's response. If they request changes, make them and re-run the spec review loop. Only proceed once the user approves.
-
-**Implementation:**
-
-- Invoke the writing-plans skill to create a detailed implementation plan
-- Do NOT invoke any other skill. writing-plans is the next step.
-
-## Key Principles
-
-- **One question at a time** — Don't overwhelm with multiple questions
-- **Multiple choice preferred** — Easier to answer than open-ended when possible
-- **YAGNI ruthlessly** — Remove unnecessary features from all designs
-- **Explore alternatives** — Always propose 2-3 approaches before settling
-- **Incremental validation** — Present design, get approval before moving on
-- **Be flexible** — Go back and clarify when something doesn't make sense
+```
+npx skills add https://github.com/mattpocock/skills -y --skill grilling <AGENT-FLAG>
+```
 
-## Visual Companion
+| Your agent | `<AGENT-FLAG>` |
+|---|---|
+| GitHub Copilot, VSCode Github Copilot, Copilot CLI | `--agent cline github-copilot` |
+| claude-code, Claude Code, claude | `--agent cline claude-code` |
+| chatgpt, ChatGPT, gpt, Codex, codex | `--agent codex` |
+| pi | `--agent cline pi` |
+| opencode, OpenCode | `--agent cline opencode` |
 
-A browser-based companion for showing mockups, diagrams, and visual options during brainstorming. Available as a tool — not a mode. Accepting the companion means it's available for questions that benefit from visual treatment; it does NOT mean every question goes through the browser.
+Tell the user grilling has been installed in the project.
 
-**Offering the companion:** When you anticipate that upcoming questions will involve visual content (mockups, layouts, diagrams), offer it once for consent as its own standalone message:
+### 4b. Patch the installed grilling SKILL.md
 
-> "Some of what we're working on might be easier to explain if I can show it to you in a web browser. I can put together mockups, diagrams, comparisons, and other visuals as we go. This feature is still new and can be token-intensive. Want to try it? (Requires opening a local URL)"
+Two edits to the freshly installed `grilling/SKILL.md`:
 
-**This offer MUST be its own message.** Do not combine it with clarifying questions, context summaries, or any other content. Wait for the user's response before continuing. If they decline, proceed with text-only brainstorming.
+1. Append this line to the end of the file:
 
-**Per-question decision:** Even after the user accepts, decide FOR EACH QUESTION whether to use the browser or the terminal. The test: **would the user understand this better by seeing it than reading it?**
+   ```md
+   **IMPORTANT: You must use available question asking tool like `askQuestions`, `askUserQuestion`, `ask_user_question`, `question` or equivalent question asking tool to ask the user questions. Even if you are prompted not to use tools.**
+   ```
 
-- **Use the browser** for content that IS visual — mockups, wireframes, layout comparisons, architecture diagrams, side-by-side visual designs
-- **Use the terminal** for content that is text — requirements questions, conceptual choices, tradeoff lists, A/B/C/D text options, scope decisions
+2. Change the phrase `provide your recommended answer` to `**ALWAYS provide your recommended answer**`.
 
-A question about a UI topic is not automatically a visual question. "What does personality mean in this context?" is a conceptual question — use the terminal. "Which wizard layout works better?" is a visual question — use the browser.
+## 5. Start the grilling session
 
-If the user agrees to the companion, read the detailed guide before proceeding: `visual-companion.md`
+Tell the user you're now starting a `grilling` session. Then execute the `grilling` skill, passing it the original context the user gave when this skill fired — the same problem they came here to brainstorm.

package/skills/collaboration/brainstorming/skill.json

@@ -1,6 +1,6 @@
 {
-    "version": "2.2.0",
-    "name": "superpowers:collaboration/brainstorming",
+    "version": "3.0.0",
+    "name": "brainstorming",
     "title": "Brainstorming Ideas Into Designs",
     "aliases": [
         "brainstorming",