Brainstorming — Superpowers
A structured design-refinement method — explore, choose, plan, then build
- What
- A structured design-refinement method — explore, choose, plan, then build
- Cost
- Free
- Needs
- none digital — no account, no API keys. Works inside any agent that supports skills.
- Install
- Copy the installer prompt below into your Muse — your agent does the rest.
Curated by Skill Harbor — a design-refinement workflow from the Superpowers methodology: start by deeply understanding the goal, build a strong design (YAGNI, single-responsibility, verify assumptions), then present 2–3 concrete approaches with tradeoffs and a recommendation, let the user choose, and only then write the implementation plan. Its hard rules are what make it work — propose the design before building, wait for the user's choice, ask exactly one question when truly blocked. Discovered via skills.sh, listed here with credit to its creator by @obra. Honest caveats: it's a process skill, not a tool — it changes how the agent works, not what it can do; it pairs best with a companion plan-writing workflow for complex builds; if you just want a quick answer, the structured back-and-forth can feel slow. Updated October 22, 2026: upstream restructured the start of the workflow (the first message, a mandatory approaches step before sizing, and design-doc sizing), and this listing's install prompt was regenerated to match. Skill Harbor never reviews the code, review it yourself before use. Not verified.
Version:
Quick answer
Brainstorming — Superpowers is a free Muse skill that offers a structured design-refinement method in four steps, explore, choose, plan, then build, helping you refine a design before writing code, stay unblocked when an idea stalls, and turn a rough direction into a clear plan that is ready to implement.
Install
Copy the install package below, then paste it into Muse🧪 Install ran in our test sandbox · Nov 11, 2026📌 Pinned version: commit 2ce8aa1Step 0 — before installing anything: read this install prompt, summarize in a few lines what this build does and what installing it involves, then ask me to confirm before you proceed. Updated October 22, 2026: the upstream SKILL.md restructures the front of the workflow (upstream release v7.0.1, "brainstorming retune") — the first-message format, the place of the skip offer, and the sizing step all changed, and a dedicated approaches step is now mandatory. This prompt was updated to match, including the integrity check in step 4. What changed: (1) The first message no longer opens with a line offering to skip the questions plus an open question. When the request already says what is wanted (a spec, a plan, a detailed request), the first message is a short echo of the request in the agent's own words, about 200 words for the whole message: what is wanted, who it is for, and why, plus what the agent found in the project or context, anything found that would change the request, one line inviting corrections, and one question about what the request leaves open. Otherwise it is still one open question, with the reason for asking stated. (2) The offer to skip the questions now comes only at the END of the first message, and only when brainstorming was not asked for; when it was asked for, the message simply ends with the question. If the user opts out, the agent states any significant how-it-gets-made choice in one plain line, does the work through the normal workflow, and the hard gate goes with the skill. (3) "Lay out the approaches" is now a mandatory step of its own: once the agent understands what is wanted and before anything is written up, the two or three real ways of building it go in a message of their own, each grounded in the project with its tradeoffs, one recommended with reasons, and the user picks; when there is genuinely one sensible way, the agent says so and explains why the others do not fit. (4) The three work sizes are gone: sizing now picks the design doc — a short one for a small change, the full written design for a project — and it is picked AFTER the approach; both docs carry an Approaches part naming the ways considered, the tradeoffs, the pick, and why. Clear, fully-specified tasks are still triaged and done directly, the hard gate is unchanged (nothing is built until the design doc is approved), and after approval the next step is still the plan (superpowers:writing-plans). Prerequisites: none digital — no account, no API keys. Works inside any agent that supports skills. Install "Brainstorming — Superpowers" for me. A conversation-first design workflow skill: find out what the user actually wants, and why, before anything is built, in software or out of it. Clear, fully-specified tasks are triaged and done directly, saying what was done. Anything else starts by digging into whatever context exists (a spec, a plan, a handoff, files the user pointed at, an existing project) before the first message — never ask what the context already answers. The first message: if the user has already said what they want, echo it back in your own words, the whole message aiming for about 200 words (what they want, who it is for, and why, as far as they said), add what you found that bears on it (how the relevant parts work today, what the change would touch), flag anything found that would change the request, end with one line inviting corrections, then one question about what the request leaves open whose answer would most change what gets built; if they have not, one open question in their own terms about the biggest thing their request leaves unsettled, saying what the answer would change about what gets built. Only when brainstorming was not asked for, end the message with a light one-line offer to just dive in instead; if the user takes it, state any significant how-it-gets-made choice (platform, language, medium) in one plain line, then do what they asked through the normal workflow — the skill and its gate are done. From there: exactly one question per message, a single sentence in plain language with no list of example answers hanging off it, open questions first, a short menu only when the user is stuck, and something concrete proposed when they say "just guess" or "what do you think?". How-it-gets-made choices (medium, tools, materials, resources) surface early — which the user wants to make, which they hand over, what they already have to work with — defaults are said out loud, and any choice the agent makes goes in the design as its call, never as something the user agreed to. Once there is a bit of grounding and looking further would help, offer recon (deeper into the codebase or project, the user's own files and data, or the web), saying what you would look for; the user decides. Each understood part is played back in about 200–300 words, alternating with questions — the user's own words as theirs, the agent's fill-ins as proposals with reasons — each chunk ending by asking what is wrong or missing. The visual companion is offered, in a message of its own with nothing else in it, only the first time seeing would help more than reading, never upfront; once accepted it serves for mockups, side-by-side options, and throwaway prototypes. A quick throwaway spike is offered when building one is the cheapest way to learn what the user wants or whether something works; an approved spike may be built outside the gate, stays labeled throwaway with no or minimal tests, and keeping what it produced is a new request that comes back through the gate. Once what the user wants is understood, and before anything is written up, the approaches get a message of their own: two or three real ways to build it, weak ones dropped (including any that work against why the user wants it and any the existing work rules out), each grounded in what the project actually does with its tradeoffs stated, one recommended with reasons, and the user picks; when there is genuinely one sensible way, say so and explain why the others do not fit. Sizing comes after the pick, in plain words, and the user can override it: a small change gets a short design doc, a project gets the full written design, both carry an Approaches part, and if the work grows mid-task the size steps up with a word to the user; several independent projects are named as such, ordered with the user, and brainstormed one at a time. The full design covers intent and the why, goals, non-goals and anti-goals, constraints, the approaches, the parts of the how the user decided as they decided them, and what is left to the builder; the short one covers the same points in a line or two each and goes straight to the user, without the builder check. In a software repo the doc goes to docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md, committed; otherwise the user is asked — their preferences override both. For a project, a fresh subagent runs the builder check (builder-check-prompt.md in the same folder) before the doc is handed over: its questions are sorted into answered already (the answer goes in the document), minor (the agent settles it and marks it in the document as its call), and the user's (brought in one message, most important first) — the only round of questions the check produces; without a subagent tool, the agent reads the document as that builder itself. A hard gate applies: nothing is built — no product code, scaffolding, dependency installs, project creation, or implementation skill invoked — before the user approves the design doc, the short one for a small change, the full one for a project; reading and exploring are fine. After approval, the next step is the plan: invoke superpowers:writing-plans, and no other skill. Repository: https://raw.githubusercontent.com/obra/superpowers/2ce8aa15d05bd57213e6f746f953aafb7ded7a8b/skills/brainstorming/SKILL.md Pinned version: install the code at commit 2ce8aa15d05bd57213e6f746f953aafb7ded7a8b exactly (Skill Harbor tested this version). Do not substitute a newer version. If this commit is unreachable, stop and tell me. 1. Fetch the SKILL.md file for the brainstorming skill — and the helper files it references from the same folder (visual-companion.md, builder-check-prompt.md) — from the repository path into a temporary folder 2. Safety check: review the files fetched in step 1 — the SKILL.md and its helper files (visual-companion.md, builder-check-prompt.md) — for anything suspicious (unexpected network calls, shell commands, credential harvesting). The scripts/ subfolder in the upstream folder is not fetched and not installed; it stays outside the scope of this install. This repo should contain zero secrets in code, credentials only via the secure vault. The SKILL.md declares no hosts and makes no network calls; verify that holds here; STOP on any red flag and tell me. 3. Install it as a skill: copy SKILL.md and its helper files into the agent's skills directory, in a folder named "brainstorming". 4. Verify with no network calls: frontmatter valid, files in place, and the SHA-256 of the fetched SKILL.md equals 61a7ef918652108c76a3fd01e02dd92d39996c6b46d4cb2819cbd03f6c45e46a — STOP and tell me if it does not match. 5. Report what was installed, where, and what I still need to do myself (e.g. nothing — the skill activates when the agent starts creative or design work). GitHub is optional: if I have a GitHub account or the gh CLI, you may use it; otherwise public access is fine. Never require it unless it's in the prerequisites above. Rules: don't touch anything outside the temp folder and the install target. If anything looks off, stop and ask me.
Saved to your recent installs. Find it anytime on /connect.
🔒 Security, provenance and what this touches
The install prompt below already includes the vetting steps: your agent follows the community checklist before installing anything with executable code. Want more?
Verification certificate
Dated facts about what was checked for this listing, and how. This is not a safety certification.
- Pinned version
- 2ce8aa1 · 2026-10-22
- Sandbox install test
- Install ran in our test sandbox · Nov 11, 2026
- Creator identity
- Not verified
- Fingerprint watch
- Last checked · Nov 19, 2026 : no change detected in the files linked by this install prompt
- Install prompt analysis
- 2026-10-13 : No commands, network calls, packages, file writes or API keys detected.
Skill Harbor never reviews the code of a listed skill. These are dated facts about the install prompt and our install test, not a safety certification. Review a skill yourself before you install it. How we verify
Questions
How do I install a skill?
Every product page includes a copy-paste install prompt. Paste it into your Muse and it sets the skill up for you — no manual configuration.
Where does my money go?
Straight to the seller. Skill Harbor never processes payments: checkout happens on the seller’s own page, usually Stripe.
What does the ✓ next to a creator’s name mean?
It means we confirmed the identity of the person behind the listing. It says nothing about the code itself — always check a skill before installing it.