Brainstorming Skill for Muse
Structured brainstorming that turns ideas into plans.
- What
- Structured brainstorming that turns ideas into plans.
- Cost
- Free
- Needs
- none beyond standard skill tooling — no external services, APIs, or accounts. You bring the fuzzy idea.
- Install
- Copy the installer prompt below into your Muse — your agent does the rest.
Turns a fuzzy idea into a solid design or spec through a structured collaborative dialogue: it works to understand the intent and context, sharpens the idea with you, presents a design, and only moves forward once you — the human partner — approve it. Meant to run before any creative work, from a new feature to a behavior change. Discovered via skills.sh. Honest note: the source text is written in an imperative tone ("You MUST use this") that you can simply ignore; the underlying methodology is generic but genuinely solid, and it works just as well as a plain prompt. 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.
Curated by Skill Harbor — free, open-source skill (MIT) by @obra.
Version:
Quick answer
Brainstorming Skill is a free Muse skill for structured brainstorming that turns ideas into plans. Rather than collecting loose ideas, it works through them systematically until a workable plan emerges. That structure helps teams move from inspiration to action without losing promising ideas along the way.
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"), and the description below was rewritten to match; where the previous version of this prompt says otherwise, the file now wins. What changed: (1) The first message no longer opens with a line offering to skip the questions followed by 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 the first message is still one open question, with the reason for asking stated. (2) The offer to skip the questions moved to the END of the first message, and it appears 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) A new mandatory step, "Lay out the approaches": 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, not before; 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, and the hard gate is unchanged: nothing is built until the design doc is approved, and after approval the next step is the plan (superpowers:writing-plans). This prompt was updated to match, including the integrity check in step 4. Prerequisites: none beyond standard skill tooling — no external services, APIs, or accounts. You bring the fuzzy idea. Install "Brainstorming Skill for Muse" for me. Run a conversation-first design dialogue that finds out what I actually want, and why, before anything gets built — in software or out of it. If my request already contains everything that matters, just do it and say what you did. Otherwise: if I gave context (a spec, a plan, files, an existing project), dig into it before your first message, and never ask what it already answers. Your first message: if I have already said what I want, echo it back in your own words — the whole message aims for about 200 words — what I want, who it is for, and why, add what you found that bears on it, flag anything you found that would change the request, end with one line inviting corrections, then one question about what my request leaves open whose answer would most change what gets built. If I have not, ask one open question, in my own terms, about the biggest thing my request leaves unsettled, and say what the answer would change. Only when I did not ask for brainstorming, add at the end a light one-line offer to just dive in instead; if I take it, state any significant how-it-gets-made choice (platform, language, medium) in one plain line, then do what I asked through the normal workflow. After that, exactly one question per message — a single sentence, plain language, no list of example answers hanging off it — open questions first, a short menu only if I am stuck, and when I say "just guess", propose something concrete. Surface the how-it-gets-made choices early (which I make, which I hand to you, what I already have to work with), say sensible defaults out loud, and mark any choice you make as your call, never as something I agreed to. Once looking further would help, offer to go look — deeper into my codebase or project, my own files and data, or the web — and say what you would look for. Play back each part you understand in about 200–300 words — only what I said as mine, your fill-ins as proposals with your reasons — ending by asking what is wrong or missing. Offer the visual companion, in a message of its own and never upfront, the first time seeing would help more than reading. Offer a quick throwaway spike when building one is the cheapest way to learn what I want or whether something works; a spike I approve 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 you understand what I want, and before writing anything up, lay out the approaches in a message of their own: two or three real ways to build it, weak ones dropped, each grounded in what the project actually does with its tradeoffs stated, one recommended with reasons — I pick; if there is genuinely one sensible way, say so and explain why the others do not fit. Then size the work in plain words: a small change gets a short design doc, a project gets the full written design — both carry an Approaches part (the ways considered, what each trades off, which I picked, and why) — and if it grows mid-task, say so and step up a size; if it is really several independent projects, say so, agree on an order with me, and brainstorm them 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 I decided as I 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 me. In a software repo the doc goes to docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md, committed; otherwise, ask me. For a project, a fresh subagent runs the builder check (builder-check-prompt.md) before you hand the doc over: sort what it asks into answered already (put the answer in the document), minor (settle it yourself and mark it in the document as your call), and mine (bring those in one message, most important first) — that is the only round of questions the check produces; without a subagent tool, read the document as that builder yourself. Hard gate: nothing gets built until I approve the design doc — building includes writing product code, scaffolding, installing dependencies, creating projects, and invoking an implementation skill; reading and exploring are fine. After I approve, 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 brainstorming skill folder from the repository path into a temporary folder — the SKILL.md plus the companion files it uses from the same folder (visual-companion.md and builder-check-prompt.md) 2. Safety check: review the SKILL.md for anything suspicious (unexpected network calls, shell commands, credential harvesting). This repo should contain zero secrets in code; credentials only via the secure vault. Verify that holds here; STOP on any red flag and tell me. 3. Install it as a skill: copy SKILL.md and its companion 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. come with the fuzzy idea or creative task to design). GitHub is optional: if I have a GitHub account or the gh CLI, you may use it; otherwise public access is fine. 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.