Dev & Engineering workflowplanningspecsuperpowersbrainstorming

Brainstorming (Requirements & Design)

Forces requirement clarification before any code gets written — hard-blocks implementation until a design is approved

FollowSkills review · FSRS-1.0
Use with care
68/ 100
Utility17 / 20

This skill provides a concrete pre-implementation process for clarifying goals, constraints, success criteria, and producing a design document. Its audience and boundaries are reasonably clear. The approval gate, alternative approaches, and section-by-section validation are useful in real agent workflows. However, requiring the full process for every task, including trivial changes, may reduce efficiency, and the skill depends on other skills such as writing-plans, so its end-to-end behavior is incomplete in isolation.

Reliability14 / 20

The ordered checklist, state diagram, approval gates, and specification self-review make behavior more reproducible. The visual companion material also documents startup, reconnection, idle shutdown, and stopping. Supporting scripts include argument validation, session isolation, PID identity checks, and failure statuses, while the repository supplies server-security test files as supporting signals; no tests were executed for this review. There is limited fallback guidance for inaccessible project context, nonresponsive users, failed document writes or commits, unavailable downstream skills, and other workflow interruptions. Key runtime components such as server.cjs and the frame template were not fully supplied here.

Safety17 / 25

The skill explicitly requires user approval before implementation and requires separate consent before offering or opening the visual companion, which supports consent and control over external effects. Supporting materials indicate useful safeguards: loopback binding by default, session keys, HttpOnly/SameSite cookies, owner-only files, cross-origin WebSocket rejection, and a stop command. Risks remain because 0.0.0.0 binding is supported, the client uses ws:// rather than encrypted transport, and session keys appear in URLs. Persistent project directories retain mockups and state, agent-written HTML is served, and browser events are sent back to the agent. Guidance is insufficient on remote exposure, sensitive data, key rotation after disclosure, and rollback or recovery of committed design documents.

Evidence8 / 15

The skill includes detailed steps, a flow diagram, checklists, design coverage requirements, and visual-companion operating instructions, providing reasonable traceability. The helper and lifecycle scripts and the repository's authentication tests offer implementation and test signals, but they do not establish that this revision was executed or passed testing; the supplied tests primarily cover server authentication rather than the full brainstorming workflow, approval gates, document commits, or cross-platform behavior. Promotional README claims are not clearly separated from verified results, and there is no versioned behavior specification, failure catalog, or independent evaluation.

Usability7 / 10

Inputs, conversational stages, the default design-document path, visual-companion startup options, returned URL, event directory, and stop command are documented. Differences across several coding-agent harnesses are also described. Costs and compatibility still depend on a particular harness, Node, browser, git, and other skills or runtime files not fully supplied here. Windows, remote containers, and background-process behavior receive guidance, but troubleshooting is not comprehensive. The workflow does not clearly define exit behavior when the user declines, cancels, stops responding, or does not want to commit or continue.

Maintenance5 / 10

The repository provides an MIT license, a package.json version, and community and issue-reporting channels, supporting a basic maintenance assessment. The publisher is unverified under the stated rule and therefore adds no governance credit. The selected skill itself has no version, changelog, compatibility matrix, named owner, release responsibility, or explicit update path. Its dependencies on other skills and runtime components not fully shown in the supplied material increase long-term maintenance uncertainty.

Evidence confidence:Low Reviewed Jul 15, 2026 Reviewed revision d884ae04edeb
Before you use it
  • Do not use --open or start the visual companion without explicit user consent; use 0.0.0.0 cautiously in remote scenarios and avoid sending sensitive content over unencrypted ws://.
  • Session keys appear in URLs and browser state, so sharing logs, screenshots, or complete URLs may grant session access; persistent .superpowers/brainstorm/ directories may also retain sensitive design material.
  • The mandatory workflow may be unsuitable for low-risk minor changes, incident recovery, or situations where the user explicitly needs immediate containment; stop and explain the limitation if writing-plans or another downstream dependency is unavailable.
  • This is a static review; the skill, server, and tests were not executed. Repository test files must not be treated as independent evidence that this revision passed.
See the full review method →

What it does & when to use it

The entry gate of the Superpowers methodology: before any creative work (new feature, new component, behavior change) begins, it forces Claude into one-question-at-a-time dialogue to surface real intent, propose 2-3 approaches with trade-offs, present the design in confirmable sections, and write the finished design to a doc before moving on. The core mechanism is a hard gate — no implementation skill, no code, until the user has approved the design.

Explores current project state (files, docs, recent commits) first; assesses whether the request needs decomposing into sub-projects; asks one question at a time (preferring multiple choice) to nail down purpose, constraints, and success criteria; proposes 2-3 approaches with a recommendation; presents the design section by section with confirmation after each; writes the final design to docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md and commits it to git; self-reviews the spec for placeholders, contradictions, scope, and ambiguity; asks the user to review the written spec; then hands off to the writing-plans skill to produce an implementation plan. Also ships an optional browser-based visual companion for showing mockups and layout comparisons.

  1. Say "add a user auth feature" in Claude Code and get asked clarifying questions instead of immediately getting code
  2. Even a seemingly trivial change ("tweak this config option") gets routed through the design-confirmation flow to surface hidden assumptions
  3. Decompose an oversized request ("build a platform with chat, storage, billing, and analytics") into separate sub-projects, each brainstormed on its own
  4. Open the optional browser visual companion when a design question is genuinely about layout or a wireframe

Pros & cons

Pros
  • The hard gate is written explicitly (an actual HARD-GATE tag), harder to route around than a generic "design first" reminder
  • Enforces one question at a time, multiple-choice preferred — matches how a real conversation should flow instead of dumping ten questions at once
  • Design docs land at a fixed path and get committed to git, so the record survives past the chat transcript
Limitations
  • Only reliably self-enforcing on harnesses that actually read and follow SKILL.md instructions (Claude Code, Codex CLI, etc.) — in a plain chat interface it's just a document a human has to apply by hand.
  • The multi-round confirmation process can feel heavy for users who just want something written quickly
  • The visual companion spins up a local browser server — worth weighing the added token cost and complexity before accepting it

How to install

Installed as part of the obra/superpowers plugin — individual skills can't be installed standalone:

  1. Claude Code: official marketplace /plugin install superpowers@claude-plugins-official; or register the community marketplace with /plugin marketplace add obra/superpowers-marketplace then /plugin install superpowers@superpowers-marketplace
  2. Also supports Antigravity, Codex App/CLI, Cursor, Factory Droid, GitHub Copilot CLI, Kimi Code, OpenCode, and Pi — see the repo README for the exact command per harness

Once installed, this skill activates alongside the other 13 Superpowers skills, auto-triggered by using-superpowers based on context — there's no separate invocation step.

How to use

No manual trigger needed — the harness invokes it automatically when it detects creative work starting. Typical flow: say "I want to build X" and Claude explores the project, then asks questions one at a time instead of writing code right away.

Compared to similar skills

Compared to a one-line system-prompt reminder like "confirm requirements before coding," this skill ships an actual checklist, flowchart, and a fixed place the design gets written to. It's the entry point of the wider Superpowers pipeline — it hands off to writing-plans and, downstream, subagent-driven-development and the other 12 skills; installing it alone gets you less than installing the full plugin.

FAQ

Can I install just this skill?
No — it ships as part of the obra/superpowers plugin, which enables all 14 skills together.
Does every small change go through the full design process?
The SKILL.md explicitly requires it for every project, including ones that look simple — simple projects just get a design that's a few sentences long.

More skills from this repository

All from obra/superpowers

Dev & Engineering

Test-Driven Development (TDD)

Iron rule: no production code without a failing test written first — code written out of order gets deleted and restarted, no "tests added after"

Dev & Engineering

Verification Before Completion

No claim of "done" or "tests pass" without fresh evidence from actually running the check — including hedges like "should" or "looks like"

Dev & Engineering

Finishing a Development Branch

Verifies tests pass, then walks you through a fixed merge/PR/keep/discard menu and cleans up worktrees by strict ownership rules

Dev & Engineering

Receiving Code Review

Bans performative agreement like "you're absolutely right!" — requires verifying feedback before implementing or pushing back

Dev & Engineering

Requesting Code Review

Dispatches a reviewer subagent with isolated context to check your changes, instead of self-grading in the same session that wrote them

Dev & Engineering

Systematic Debugging

Requires completing root-cause investigation before proposing any fix — explicitly bans "just try changing this and see"

Dev & Engineering

Writing Plans

Breaks requirements into 2-5-minute tasks an implementer with zero codebase context could follow verbatim — bans placeholders like "TBD" or "fill in details"

Dev & Engineering

Subagent-Driven Development

Dispatches a fresh implementer subagent per task in the same session, with two-stage review and a progress ledger that survives context compaction

Dev & Engineering

Executing Plans

Batch-executes an already-written implementation plan with human checkpoints, for sessions without subagent support

Dev & Engineering

Using Git Worktrees

Prefer the platform's native isolation tool before starting new feature work; fall back to manual git worktrees only when no native tool exists

Dev & Engineering

Dispatching Parallel Agents

Fan out 2+ genuinely independent tasks to parallel subagents in one shot instead of queuing them sequentially

Dev & Engineering

Writing Skills (Authoring & Testing Skills)

Applies TDD's red-green-refactor to writing skill documentation itself — expose real failure modes with a no-skill baseline test first, then write targeted guidance instead of guessing

Dev & Engineering

Using Superpowers (Bootstrap)

The entry-point skill for the whole Superpowers system — mandates invoking a relevant skill whenever there's even a 1% chance it applies

Related skills