Ideate

Ideate

Turns a problem statement into a small set of validated, evolved ideas by simulating a nominal group of independent generators, scoring with independent judges, and breeding the winners — instead of asking one context for a list and polishing it.

This SKILL.md is a thin index. Phase procedures live in rules/*.md and load on demand. The evidence behind every numerical default lives in references/ideation-research.md — section references below (§) point there, and its defaults tables flag which numbers are study values vs the skill's own operationalizations.

Contents

• Mode Detection
• Workflow
• Quick vs deep
• Composition
• Core Principles
• Self-Improvement
• Anti-patterns
• Definition of Done

Mode Detection

Parse $ARGUMENTS:

Everything else in $ARGUMENTS is the problem statement. If it is missing, ask for it — never ideate on a guessed problem.

Depth triage (auto mode)

First match wins:

Cost expectation: a deep run with a typical 2–4-idea finalist band dispatches ~17 subagents (2 bursts × 5 generators, 1 pool judge, 1 breeder, 1 variant judge, 3 panel judges, 1 pre-mortem) — prefer quick for casual or budget-sensitive asks. A richer pool that admits more finalists adds only panel-judge cost, not generation cost.

Workflow

Phase 0 — Intake & triage

1. Read lessons (advisory input for mechanics only — see the hard invariant under Self-Improvement). Narrow-to-broad LoreKit fan-out; skips silently if memory.* is not connected:

   memory.list { scope: "repo::{owner}/{repo}", tags: ["loop::ideate-lessons"], limit: 50 }
   memory.list { scope: "global",               tags: ["loop::ideate-lessons"], limit: 50 }
   

2. Restate the problem in one sentence and name the success criterion — what makes an idea "good" here (cheapest, most novel, shippable this week, …).

3. Run the depth triage table unless a mode token was given.

4. If the user supplied seed ideas, add them to the pool unlabeled — judges must not know which ideas are the user's.

Phase 1 — Frame

Problem framing measurably shapes ideation breadth and direction (§2.5) — skip only with --no-framing.

1. Generate 3–5 "How Might We" framings at deliberately different widths, from the literal ask to the underlying job-to-be-done — the width variation is the evidenced part (§2.5); the HMW phrasing is convention.
2. Interactive session → ask the user to pick one (a single batched question). Autonomous or backgrounded → pick the framing one step wider than the literal ask, and log the choice in the report.

Quick vs deep

Composition

confidence is required; the others are optional — skip silently if not installed / not connected.

Core Principles

1. Simulate a nominal group, not a meeting. Independent generation contexts, pooled afterwards — never one long list from one context (§1.2, §4.3).
2. Strictly separate generation from evaluation. The one Osborn rule that survives scrutiny; no feasibility talk inside a generation pass (§3.1).
3. Diversity comes from personas and prompts, not temperature. Temperature is a weak novelty lever with a coherence cost (§4.6).
4. The judge is never the generator. Self-scoring amplifies self-bias per iteration (§4.7, §5.1).
5. Protect novelty at selection. Default selection sacrifices originality for feasibility and performs near-randomly; always carry one high-novelty pick (§3.2).
6. Gate finalists on quality, not quantity. The finalist count is emergent: report every idea that clears the admission bar, not a fixed top-3. A fixed count drops deserving ideas from a rich pool and pads a thin one (§3.2).
7. Iterate by recombination across lineages, not polishing. Cap at 3 rounds; stop on flat external scores (§5.1–§5.3).
8. The obvious ideas come first. Always run a second burst seeded with "what has NOT been said yet" (§1.5).
9. Pre-execution novelty is inflated. Every finalist needs a concrete first-step probe before it is recommended (§4.2).

Self-Improvement

Two-tier loop, scope ideate-lessons — full contract in rules/self-improvement-loop.md, diagnostic surface in rules/diagnostic-surface.md.

Hard invariant: divergence runs lessons-blind. Lessons may inform mechanics — depth triage, operator effectiveness, judge calibration, stopping behavior — and must never seed, filter, or steer idea content. "What kinds of ideas the user tends to pick" is on the never-store list: it would entrench homogenization, the exact failure this skill exists to avoid.

Anti-patterns

• One 30-idea list from a single context — within-context fixation makes the last 20 near-duplicates.
• Scoring or feasibility talk during a generation pass.
• Letting the generation context judge its own output.
• Averaging the four axes into one number before selection, then picking the top-n — this silently discards every high-novelty idea.
• Capping the report at a fixed 3–4 finalists regardless of how many ideas cleared the quality bar — the count is emergent, not a target.
• Treating the "Ideas worth revisiting" section as a throwaway list — it must name why each near-miss missed and what would flip it; that is the inspiring part.
• A 4th evolution round because it "still feels like it's improving" — self-assessed improvement is the signal that lies.
• Storing user idea-taste as a lesson.

Definition of Done

• Problem restated and success criterion named before any generation.
• Generation and evaluation never co-occurred in one pass.
• Pool met the unique-idea gate for the chosen depth.
• Every finalist has all four axis scores, an executability probe, and the confidence gate result.
• The finalist count reflects the quality bar, not a fixed target — every idea that cleared the admission bar is reported (or capped only by an explicit --n).
• Report includes the high-novelty wildcard, the run stats (bursts, non-duplicate yield, evolution rounds, score trajectory), and an "Ideas worth revisiting" section that names, per near-miss, why it missed and what would flip it.
• User verdict requested; lessons written per the loop contract.