| name | brainstorm |
| description | Divergent idea generation — many candidate ideas across several frames with judgment deferred, then a clustered shortlist. Use to open a solution space wide, or /brainstorm. Not for developing one idea (ideate) or picking one (propose). |
brainstorm
The divergence skill. Given a problem or opportunity, it generates a wide set of candidate ideas across
several framings — with judgment deliberately deferred so quantity comes first — then clusters them and
surfaces a shortlist worth developing. It opens the space; it does not close it. Deciding among the
candidates is propose; developing one into a shaped concept is ideate.
It is read-only and advisory: it writes an IDEAS.md (candidates + clusters + a shortlist with a one-line
why), never product code. The output is judged by Review — is the space genuinely wide (multiple
distinct frames, not variations on one), and is the shortlist reasoned?
What this does / does not do
Does: restate the problem + any constraints; generate many candidates across distinct frames (e.g. remove
the problem, borrow from another domain, invert the constraint, brute-force, minimal); defer judgment during
generation; cluster near-duplicates; surface a shortlist with a one-line rationale each; write IDEAS.md +
a receipt. Does not: converge to a single recommendation (that is propose), develop one idea in depth (that
is ideate), build a proof-of-concept (that is prototype), or write product code.
When NOT to use
- The direction is already chosen and needs developing into a concept — use
ideate.
- A decision among known options is needed — use
propose (tradeoffs + a pick).
- The unknown is feasibility and needs a throwaway build to answer — use
prototype.
- The task is execution, not ideation — go to the pipeline (specify → decompose → executor).
Inputs
- The problem / opportunity statement + any hard constraints (budget, time, platform, non-goals).
- Optional context:
state/project-map.md, the intake/spec if one exists.
How to do it
- Frame the problem. Restate it in one line + list the hard constraints; a wide space still respects the
non-negotiables.
- Diverge across frames. Generate candidates from several distinct angles — deferring judgment. Aim for
breadth (many frames), not ten variants of one idea.
- Defer judgment. During generation, do not filter for feasibility — a bad-looking idea often seeds a
good one. Capture everything.
- Cluster. Group near-duplicates; name each cluster by its underlying approach.
- Shortlist. Surface the few candidates worth developing, each with a one-line why and the frame it came
from. Note what was deliberately parked.
- Write
IDEAS.md — candidates (by cluster) + the shortlist + parked ideas.
Output
- IDEAS.md at the product root (or
ideas/IDEAS.md if that dir exists) — persistence: Ephemeral.
Problem + constraints · candidates grouped by cluster/frame · shortlist (with a one-line why + frame) ·
parked ideas.
- receipt (
<workspace>/receipts/brainstorm-receipt-<ts>.json): base schema + topic, frames_used,
candidate_count, cluster_count, shortlist, ideas_path. persistence: Ephemeral.
Completion Criteria
Done when: IDEAS.md holds candidates generated across several distinct frames with judgment deferred,
clustered, with a reasoned shortlist and the parked set noted; a receipt records the frames + counts.
Not done if: the "ideas" are variations on a single frame (no real divergence); generation was filtered
for feasibility as it went (premature convergence); or it converged to one recommendation (that is propose,
not brainstorm).
Next step: ideate develops a shortlisted idea into a concept; propose decides among the shortlist;
prototype de-risks the chosen one.
Related Skills
- ideate: develops ONE direction in depth.
brainstorm produces breadth; ideate produces depth on a
pick from it.
- propose: converges to a single recommended approach with tradeoffs.
brainstorm feeds it options.
- prototype: plans a throwaway build to answer a feasibility unknown a shortlisted idea raises.
