ideate git:20260716.ac81253A

Immutable. This exact content is served forever at /api/v1/blob/d65fcc7ec87ee811.

---
name: ideate
description: >-
  Structured idea generation for a project or a blank-slate problem — ideas
  worth pursuing, not the first one that sticks. Grounds in the current repo
  (AGENTS.md/README) or a freeform problem, then diverges across named lenses
  (adjacent user, removed constraint, inversion, and more) so a run yields
  range, not ten variations of one idea. Fights premature convergence —
  nothing judged until the divergence quota is met — then verdicts each idea
  EXPLORE/PARK/DROP, where DROP is cheap. EXPLORE items become seeds for
  priorart (is it novel?) or feature (build it); verdicts persist in
  out/ideate/tracker.md so repeat runs open with what's new. Keyless. Use to
  generate, brainstorm, or explore ideas or new directions for a project or
  problem — e.g. "/ideate", "/ideate <topic>", "brainstorm features for X".
  For whether an idea already exists use priorart; for competitor features
  use scout; for choosing between named options use verdict.
---

# 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`](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.