Ideate

ideate — diverge before you converge

/ideate — generate ideas for THIS repo (reads its AGENTS.md/README) /ideate <topic|problem> — generate ideas for an arbitrary problem, no repo needed

Answer one question: what could this become that isn't obvious yet — and which of those directions actually deserves effort? Both halves matter. A session that only sprays ideas is a whiteboard; one that judges before it has range is just the first idea wearing a verdict. The deliverable is a short list of directions each carrying its own reason to live or die.

The enemy the whole skill is built against is premature convergence — latching onto the first plausible idea and spending the session polishing it. Every step below exists to hold divergence open long enough to be worth converging on.

Step 0 — Frame the ground

You cannot diverge from nothing; fix a starting point first.

• With a repo (/ideate alone): read AGENTS.md (the map skill writes it), README, and the top-reacted open issues. Distill the project's job in one sentence and its differentiation axis — the thing it does that alternatives don't, which every later verdict is judged against.
• With a topic (/ideate <problem>): restate the problem in one sentence and name the user and the constraint that hurts most. Missing pieces are assumptions — state them, don't invent facts.
• Read out/ideate/tracker.md if it exists: ideas already generated, verdicts already made. A DROPped idea isn't re-raised unless something changed; repeat runs open with "Since last ideate" — what's new in the repo or problem since.

Completion criterion: job, user, and differentiation/constraint written down before any idea is generated.

Step 1 — Diverge (judgment forbidden here)

Generate ideas by working the lenses in references/lenses.md — do not freehand a flat list, which is how every session collapses into variations of one idea. Take each lens in turn and force at least one idea from it, even a weak one; range comes from the lenses being different, not from trying harder on one.

Hard rule: no evaluating, ranking, or "but that won't work" until the quota is met — aim for at least two ideas per lens worked. Judging mid- divergence is premature convergence by another name; a bad idea from an unworked lens is worth more here than a safe idea restated.

Completion criterion: every applicable lens worked, quota met, ideas captured verbatim — no pruning yet.

Step 2 — Cluster and sharpen

Now converge, but only halfway. Group the raw ideas into clusters of the same underlying bet; within each cluster keep the sharpest single statement and fold the rest into it. Kill exact duplicates. For each survivor write one line: what changes for the user if this exists. An idea whose user-impact line can't be written is a DROP waiting to happen — surface that now, not after building.

Completion criterion: a deduplicated list, each survivor with a one-line user impact.

Step 3 — Verdict each survivor

Every surviving idea gets exactly one label, with a reason:

• EXPLORE — worth real effort next. Must clear two bars: it advances the differentiation axis (or genuinely relieves the worst constraint), and its effort is justified by that impact. "It sounds cool" clears neither.
• PARK — plausible but not now; record the trigger that would revive it.
• DROP — off-axis, redundant, or impact doesn't pay for effort. DROP is the cheap default; a session that EXPLOREs everything has judged nothing.

Hand off cleanly: each EXPLORE is a ready seed — route it to priorart (does it already exist before you build?) or straight to feature (build it). Name the handoff in the verdict.

Completion criterion: every survivor labeled EXPLORE / PARK / DROP with a reason, and every EXPLORE names its next skill.

Step 4 — Persist

Append the run to out/ideate/tracker.md: date, the frame (job + axis), and every idea with its verdict and reason — including DROPs, so they aren't re-raised next run. This is the memory that lets the next /ideate open with "Since last ideate" instead of regenerating the same list.

Completion criterion: tracker written; run reproducible from it.