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.

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

Mode Detection

Parse $ARGUMENTS:

Mode	Default	Trigger
`quick`		`quick` token, or auto-triage says small.
`deep`		`deep` token, or auto-triage says open-ended.
auto	yes	No mode token — run the depth triage table below.

Flag	Default	Meaning
`--n <count>`	unset	Optional cap on the Lead-finalists list. Unset by default — the finalist count is emergent from the quality bar (see `idea-scoring.md` § Selection rules). `--n` only narrows; it never manufactures finalists the bar did not admit.
`--no-framing`	off	Skip Phase 1 (problem is already well-framed).

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:

#	Signal	Depth
1	User asks for thorough / extensive / "really new" ideas, or the problem combines ≥ 2 domains ("X meets Y").	`deep`
2	Outcome is a product, business, strategy, or roadmap decision.	`deep`
3	Problem is a local decision: naming, small feature shape, workaround, single component.	`quick`
4	User is mid-conversation and wants options fast ("any ideas?", "what do you think?").	`quick`
5	Unsure.	`quick`, and name the escalation path: "run `/ideate deep <problem>` for the full pipeline".

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	Name	Rule file	Gate
0	Intake & triage	(inline below)	Problem restated in one sentence; success criterion named; depth chosen; lessons read.
1	Frame	(inline below)	3–5 "How Might We" framings at different widths; one selected and logged.
2	Diverge	`rules/divergence.md`	Pool ≥ 12 (quick) / ≥ 25 (deep) unique ideas; zero evaluation happened during generation.
3	Score	`rules/idea-scoring.md`	Every pooled idea scored on 4 independent axes by a non-generator judge.
4	Evolve	`rules/evolution-loop.md`	≤ 3 rounds; stopped on flat external scores, never on self-assessed improvement.
5	Validate	`rules/idea-scoring.md` § Finalist validation	Every finalist has an executability probe; `confidence(analysis)` ≥ 70 on the recommendation.
6	Report	`templates/ideation-report.md`	Report emitted; finalist count reflects the quality bar; high-novelty wildcard included; "Ideas worth revisiting" filled; verdict question asked.
7	Learn	`rules/self-improvement-loop.md`	Lessons written — mechanics only, never idea content.

Phase 0 — Intake & triage

Read lessons (advisory input for mechanics only — see the hard invariant under Self-Improvement). Narrow-to-broad LoreKit fan-out; skipped with one report line 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 }
```
Restate the problem in one sentence and name the success criterion — what makes an idea "good" here (cheapest, most novel, shippable this week, …).
Run the depth triage table unless a mode token was given.
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.

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.
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

Aspect	`quick`	`deep`
Generation	In-context, 2 bursts × 8 ideas, operators rotated per burst.	5 parallel persona subagents × 6 ideas per burst, ≥ 2 bursts (§1.4, §4.4).
Fixation guard	Operator switch + "what has NOT been said yet" reseed (§1.5).	Independent contexts — the structural fix (§4.3).
Judging	Separate in-context pass with rubric, order-swapped pairwise.	Fresh judge subagent; panel of 3 judges for finalists (§4.7).
Evolution	≤ 1 round.	≤ 3 rounds (§5.1).
Report	Inline.	Inline + written to `.agent/ideate/<yyyy-mm-dd>-<slug>.md`.

Composition

Skill	When	Call
`confidence`	Phase 5, on the finalist recommendation.	`Skill("confidence", "analysis")`
`critical`	Deep mode, top finalist (automatic); any finalist on request.	`Skill("critical", "analysis")` — run inside a fresh subagent so the pre-mortem stays adversarial and the main context stays lean.
`ux`	Finalists that are UI/UX or product-surface concepts.	`Skill("ux")` as a lens on the finalist.
`lorekit-memory` (LoreKit `memory.*` tools)	Phases 0 and 7.	See `rules/self-improvement-loop.md`.

confidence is required; the others are optional — a missing one never blocks, and is reported in one line (<name> — skipped (not installed | not connected)), never silently.

Core Principles

Simulate a nominal group, not a meeting. Independent generation contexts, pooled afterwards — never one long list from one context (§1.2, §4.3).
Strictly separate generation from evaluation. The one Osborn rule that survives scrutiny; no feasibility talk inside a generation pass (§3.1).
Diversity comes from personas and prompts, not temperature. Temperature is a weak novelty lever with a coherence cost (§4.6).
The judge is never the generator. Self-scoring amplifies self-bias per iteration (§4.7, §5.1).
Protect novelty at selection. Default selection sacrifices originality for feasibility and performs near-randomly; always carry one high-novelty pick (§3.2).
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).
Iterate by recombination across lineages, not polishing. Cap at 3 rounds; stop on flat external scores (§5.1–§5.3).
The obvious ideas come first. Always run a second burst seeded with "what has NOT been said yet" (§1.5).
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.

About this skill

Contents