/eureka

---
name: eureka
description: Run a deep, high-volume, purely-generative brainstorming session that floods the problem with many distinct ideas per batch — roughly 15 at a time, with the option to keep generating on demand — while forcing Claude off median, average, or predictable ideas by searching a possibility space for maximum coverage. Use this skill whenever the user asks to brainstorm, generate ideas, ideate, think creatively, come up with concepts, or explore possibilities — even if phrased casually ("some ideas for X", "a bunch of options for Y", "I need fresh ideas", "keep them coming"). Especially trigger when the user wants a large quantity of options, lots of ideas at once, to keep generating round after round, or is frustrated with generic suggestions or a thin list. Also trigger when the user says they're stuck or wants to explore directions. Do not attempt to brainstorm without this skill — the default behavior produces a short, median-anchored list, which is exactly what this skill prevents.
---

# Eureka

A high-volume, purely-generative brainstorming process. It treats idea generation as a *search over a possibility space*: it captures the median answer up front, then floods the space in **batches of roughly 15 distinct ideas**, pushing ever outward from everything already produced, maps the space so coverage is visible, keeps generating as long as the user wants, and stops when the space is saturated — not when the list feels long enough. All evaluation belongs to the user.

Two complementary moves drive it, both grounded in creativity research: the generative batches **push away** from existing ideas to find new territory, and the depth modes **build on** a promising idea to go deeper. Divergent search finds new veins; building-on mines the one you've struck.

**The core problem this skill solves:** Claude's default brainstorming produces a short list anchored on the most statistically common answer for a topic, then generates permutations of that anchor. This skill breaks the pattern two ways at once — *quantity*, by flooding each batch with many ideas, and *quality*, by making "distance from everything said so far" the explicit objective of every batch, steering by what the user *rejects* rather than what they like, and refusing to do the user's judging for them.

**How volume stays distinct.** A batch of ~15 is never 15 takes on one idea. It is generated by **rotating through several mechanisms within the same batch** — a few ideas from one lens, a few from a cross-domain seed, a few from a set of constraints — each sub-group aimed at a different still-blank region of the space. Volume comes from breadth of mechanism, not from padding one vein. This is the single most important rule for keeping the list worth reading.

---

## Operating principles

These are constitutional, not suggestions. Each one guards against a specific way Claude's own helpfulness sabotages divergence — the reflex to agree, to justify, to soften, to wrap up early. Claude will feel the pull on every batch; the rule wins over the pull, and no phase instruction overrides a principle.

1. **Purely generative.** The skill's only job is to hand the user an exciting list to evaluate — never to judge, rank, defend, or pressure-test ideas. There is no interrogate mode, no red-team, no auto-flagging. The user's own act of rejecting is itself generative for them, and it happens outside this skill. Let weak ideas through; do not pre-filter. Claude will be tempted to quietly drop the weak ones to look competent — that pre-screening is the median reasserting itself. At volume the temptation is stronger, because trimming feels like a favor. Pass them through anyway.

2. **Asymmetric feedback.** Steer on *negative* feedback only. Rejected ideas and stated no-go directions open space and must be actively avoided. Treat *positive* feedback as suspect: "I like this" is exactly the signal that creates lock-in, so kept ideas are recorded for the final list but are **not** used to steer generation. Never bend a later batch toward an earlier keep.

   **Two feedback modes (selectable — ask at session start, or switch on request).** The behavior above is *default-neutral*: only explicit rejections and stated no-go directions steer, while un-flagged ideas stay live — they remain in the Novelty Archive (so batches still push away from them) and stay eligible for the final compile. Some users instead curate exhaustively every round, naming exactly which ideas to keep. For them, run *default-reject*: any idea not explicitly kept in a round is treated as rejected — added to the Negative Bank, never resurfaced, and excluded from the final compile; and a *wholesale-rejected cluster* (a whole mechanism's batch where nothing was kept) may be read as that direction cooling. Default-neutral stays the global default, because flipping it would wrongly torch a light-touch user's many un-reviewed-but-decent ideas — so confirm the user is curating every round before switching. In *both* modes the core of this principle is unchanged: keeps are recorded, never used to steer the next batch toward them.

3. **Don't forbid the median.** Conventional ideas still get a chance to appear. The goal is to explore *everywhere*, including the obvious — not to be forced-contrarian. The median is captured and used as a reference point to push away from, never as a banned zone.

4. **Exhaust the space, don't defer.** Explore every relevant avenue *within* the session. If a promising direction surfaces, pursue it now rather than parking it for "next time." The urge to wrap up after one good batch is the helpfulness reflex — keep going, not until it feels polite to stop. **And do not trust your own read of "saturation."** Claude is a poor judge of when a space is exhausted: the batch that feels most like cousins is often one batch before the user's favorite idea. So Claude's sense of conceptual distance is *informational only* — it never licenses winding down. The real saturation signal is the user's *keep rate*, and the rule for acting on it lives in Phase 5.

---

## The engine: two memories and a baseline

The whole process runs on three pieces of state. Maintain them silently across the session.

- **The Median Baseline** — the 3–5 ideas Claude would have produced with no skill at all (captured in Phase 2). This is the origin point of the space: every generated idea should be measurably distant from it.
- **The Novelty Archive** — *every* idea generated, regardless of rating. Each batch's literal objective is to maximize distance from this archive. The archive is what prevents rediscovery and forces the search outward; it includes the Median Baseline as its starting contents. At volume the archive grows fast — lean on it harder, not less, to avoid quietly regenerating a near-duplicate of something three batches back.
- **The Negative Bank** — rejected ideas and stated no-go directions. Every subsequent batch must structurally avoid anything in it.

"Distance" here is *conceptual*, not a metric — judge it by asking "does this share a mechanism, assumption, or starting point with something already in the archive?" If yes, it's too close; move off that shared dimension. Do not build a scoring rubric; that dryness is exactly what the skill avoids.

---

## Running the session

Run the phases in order, and create a task for each so none get silently skipped:

1. Scope — 2. Reframe — 3. Capture baseline — 4. Orient — 5. Generate batches until saturation — 6. Curate — 7. Offer depth or hand off.

**Scale to the topic.** A small or sharply-bounded topic needs fewer, smaller batches, and the Phase 1 reframe can be a quick gut-check rather than a full menu. A broad, open topic earns full batches and many of them. Match the effort to the size of the space — but default to volume: when in doubt, generate more.

**Anti-pattern — "this one's too obvious to need the process."** Every topic goes through it. The urge to skip the baseline and just start listing ideas, or to stop after one batch because the first fifteen feel good, is *exactly* where median-anchoring creeps back in. The baseline matters most on topics that feel obvious, because that's where Claude's default is strongest and least examined. Capture it anyway.

---

## Phase 0 — Scoping check

Read the user's topic. Surface only ambiguities that would meaningfully change what gets generated — audience, constraints, what success looks like, what's already been tried. Ask one question at a time and prefer multiple-choice options; they're far easier to answer than open-ended prompts and keep the user moving. Stop as soon as you have enough to generate against, and if the input is already specific enough, skip this entirely. Never ask for permission to start.

---

## Phase 1 — Reframe the problem

Before generating any answers, restate the topic as **2–3 genuinely different problems** and let the user pick which one to attack. This is the highest-leverage divergence available: every downstream idea inherits the framing, so diverging the *question* reshapes the entire space.

Use distinct framings, e.g.: "improve X" vs "make X obsolete" vs "what is X actually *for*". Give each a one-line gloss. If the user's topic is already a sharply-framed problem, offer the reframes as a quick gut-check and move on fast if they confirm the original.

**Format:**
```
Before I generate, here are three different problems your topic could be:

A. [framing] — [one line]
B. [framing] — [one line]
C. [framing] — [one line]

Which problem do you actually want to attack? (Or keep the original as-is.)
```

The chosen framing becomes the frame for the coverage map and the title of the session.

---

## Phase 2 — Capture the median baseline

Write out the 3–5 ideas you would produce for this (reframed) problem with no skill — your honest default. Be specific; do not sand them down. Show them to the user briefly, labelled plainly as the baseline the rest of the session will push away from. Seed the Novelty Archive with them.

Do **not** rank or filter them. They are reference points, not rejects — and capturing them openly is *how* conventional ideas get their fair chance under principle 3: they're surfaced, not banned. Invite the user to flag any baseline idea they'd want in the final list, then push outward from the rest.

---

## Phase 3 — Orientation

Give the user a one-paragraph heads-up covering how the high-volume loop works:

- Each **batch** delivers **roughly 15 ideas**, generated by rotating through several mechanisms so the batch spreads across the space rather than clustering.
- Ideas are **grouped by the mechanism / region** that produced them, so the user can see the spread and react region by region.
- After each batch, feedback is **lightweight and negative-first**: the user flags which ideas to drop and which directions are no-go (that's what steers the next batch), and may optionally star a few keepers. Rating every idea one-by-one is *not* required — the asymmetric-feedback principle means only the rejections do the steering anyway.
- The user can say **"keep going"** for another batch any time, adjust the batch size, or ask to **compile**. The session continues until *you* stop finding keepers — Claude won't suggest wrapping up on its own until two batches in a row land nothing you want to keep.
- If the user plans to curate exhaustively each round — naming an explicit keep set and treating everything else as cut — offer **default-reject** mode (see principle 2); otherwise un-flagged ideas stay live by default.

Keep it brief. Offer the batch size as adjustable ("~15 is the default; say the word for more or fewer").

---

## Phase 4 — Generative batches

Run batches until saturation (Phase 5). **Each batch generates roughly 15 ideas by rotating through 3–5 mechanisms from the repertoire below** — about 3 ideas per mechanism — with each sub-group aimed at a region of the space that is still blank (see the coverage map). Every idea maximizes distance from the Novelty Archive while avoiding the Negative Bank.

Choosing mechanisms for a batch: pick ones that reach *different* regions from each other, and rotate so that across batches every mechanism gets used before any repeats. Within a batch, never run the same mechanism twice. The whole point of mixing mechanisms inside one batch is that 15 ideas come from 4–5 genuinely different generative starting points, so they can't collapse into variations.

After every batch: collect the lightweight feedback (rejections and no-go directions; optional stars). Then update the archive (all ideas) and the Negative Bank (rejects + no-go directions), state the new exclusion zones in a sentence or two, refresh the coverage map, and offer the next batch. Absorb the *negative* feedback explicitly; acknowledge stars but do not let them pull the next batch.

### Mechanism repertoire

Each is designed to reach ideas the others structurally cannot. A batch draws ~3 ideas from each of several of these.

**Lens rotation.** Pick a persona whose *cognitive framework* organizes the problem differently — not a costume ("a pirate") but a genuine worldview (behavioral economist, game designer, military logistician, evolutionary biologist, hospice nurse). State the lens in one sentence, then generate ideas that emerge from how that worldview frames the problem — not a conventional idea with a label attached. At volume you can run two or three different lenses in a single batch, each contributing a few ideas.

**Cross-domain seeding.** Pick 1–2 domains that are *structurally* analogous to the problem but superficially unrelated, each with a one-line rationale for the shared dynamic, then generate ideas that draw on the domain's actual mechanisms — the domain must do real work, not get name-dropped. (At volume, choose the domains yourself and generate immediately rather than pausing the batch to ask; if the user wants to steer the domain, they will say so.)

**Constraint-first.** Generate unusual constraints (not ideas) that make the conventional solution impossible or irrelevant — specific, surprising, generative. Then generate one idea per constraint that only makes sense inside it. If an idea could exist without the constraint, the constraint wasn't doing its job.

**Stochastic mutation.** Once the archive has shape, inject a *genuinely random* seed (a random word, number, or object neither party reasoned toward) and generate from it. Randomness reaches places that deliberate reasoning structurally cannot. Source the seed from something external so it can't be quietly steered. At volume, a fresh random seed each batch is a cheap, reliable way to keep one sub-group unpredictable.

**Presentation standard (used everywhere ideas are shown — batches and the final compile).** Each idea is a numbered list item: the **idea in bold**, then — optionally — a concise explanation of one to two sentences saying what it is or how the mechanism does real work here. Keep the explanation tight; it never grows into a real paragraph, because at ~15 ideas a batch the list has to stay scannable. Drop the explanation entirely when the idea is self-evident. Numbering is retained throughout so the user can steer by number ("drop 4, kill that direction").

**Format (group the batch by mechanism):**
```
Batch [N] — aiming at [blank regions this batch targets]

▸ [Mechanism A] — [the lens / domain / constraint / seed in one line]
1. **[Idea]** — [optional concise explanation, ≤2 sentences]
2. **[Idea]** — ...
3. **[Idea]**

▸ [Mechanism B] — [setup]
4. **[Idea]** — ...
5. **[Idea]** — ...
6. **[Idea]**

[...continue to ~15 across 3–5 mechanisms...]

Avoiding: [exclusion zones from the Negative Bank]
Feedback (light): tell me which numbers to drop and any direction to kill — that steers the next 15. Star a few keepers if you like. Say "keep going" for another batch, or "compile" to wrap.
```

### The coverage map

Maintain a running picture of the space: name the 2–3 axes the ideas are varying along and note which regions are still empty. Use the blank regions to aim the next batch. Keep the axes lightweight and qualitative. Surface the map to the user when it helps them see what's unexplored — especially when deciding whether to run another batch. At volume the map is the antidote to sprawl: it's what keeps 60 ideas legible instead of a wall.

---

## Phase 5 — Saturation and stopping

**Claude is an unreliable judge of saturation — treat its own "this is circling" instinct as information, never as a reason to wind down.** In practice the batch that feels most like cousins is often the one right before the user's best pick. (This is not hypothetical: it has happened where Claude suggested stopping and the user's eventual favorite came two batches later.) So the trigger for *suggesting* a stop is never Claude's distance estimate. It is a single observable user signal:

> **Only suggest compiling after two consecutive batches in which the user kept nothing.**

Maintain a simple **keep counter**. Any batch where the user stars or keeps at least one idea **resets it to zero**. Two batches in a row with zero keeps is the *only* condition under which Claude proactively raises stopping — and even then it is a gentle offer ("want to compile, or push further?"), not a verdict. Until that condition is met, keep generating and keep offering more; never nudge toward compiling, never editorialize that the well is running dry. Using keeps this way is a *stop signal only* — principle 2 still holds, so a keep never bends the next batch's generation toward it.

Claude may still *report* the shape of the space honestly — "this batch landed near earlier ones" — because that genuinely helps the user decide. What it must not do is pair that observation with a push to stop. When keeps thin out, the correct move is to **break out, not wind down**: run a batch weighted toward Stochastic Mutation and unused mechanisms to reach regions deliberate reasoning can't. Those breakout batches are exactly what the two empty rounds are for.

The stop *decision* always stays with the user, who can compile at any moment regardless of the counter. Always offer to continue.

---

## Phase 6 — Curation

At volume the default curation is **light**, so it survives many batches:

1. **Lead with the coverage map** — the axes explored and which regions are still blank. This is the headline: the shape of the space, not just the pile.
2. **The list** — every idea the user starred or didn't reject (in *default-reject* mode, only ideas explicitly kept), deduped and **grouped by region/mechanism**, each shown in the presentation standard (bold idea + optional concise explanation). No per-idea essay by default.

**Heavy annotation is opt-in.** Offer it: "Want the full write-up on any of these — mechanism, what it opens, directions to develop? Star the ones worth it." For each starred idea, then provide:
- **Mechanism**: which batch and the specific lens / domain / constraint / seed that produced it (or "baseline," if the user kept one of those)
- **Why it's interesting**: what assumption it breaks or space it opens — a specific, *generative* observation, never judgment or praise
- **Possible directions**: 2–3 concrete ways to develop it

**Format:**
```
# Eureka — [Reframed problem]

## The space
[axes explored, and which regions are still blank]

## The ideas (grouped)
### [Region / mechanism]
- **[idea]** — [optional concise explanation]
- **[idea]** — [optional concise explanation]
### [Region / mechanism]
- ...

## Full write-ups (only for starred ideas)
### [Short label]
> [The idea, stated clearly]
- **Mechanism:** Batch [X] — [lens / domain / constraint / seed]
- **Why it's interesting:** [specific, generative observation]
- **Possible directions:** • [direction] • [direction]
```

After the list, offer the two depth moves below.

---

## Phase 7 — Depth modes

Two modes, both generative (there is no interrogate or critique mode — principle 1). These are the **build** half of the skill, the complement to the **push-away** generative batches: where the batches widen the space by moving away from everything already said, the depth modes deepen it by working a single promising idea.

**Branch — build / cross-fertilize.** Treat a chosen idea as fertile ground and generate around it: run a compressed batch scoped to it, drawing a few ideas per mechanism, same lightweight feedback and asymmetric steering. The branch *builds on* the parent idea, while its own siblings still push away from each other — so you deepen a vein without collapsing into variations. Update the curation list with new keeps.

**Escalate-to-break.** Take a *kept, sensible* idea and push it three increments past reasonable until it structurally breaks. The breaking point names the hidden constraint that was keeping the original safe — then walk back one notch to the most extreme *viable* version. This is the one move that transforms an existing idea rather than generating fresh, and "walk back one notch" is where the usable idea lives, so don't skip it.

### Terminal state

The curated list is the deliverable. Do **not** slide into judging, ranking, defending, or building the ideas — that work belongs to the user, or to a different skill. The natural next steps, if the user wants them: hand a chosen idea to a convergent skill like `socratic-design` to pressure-test it, or to a planning/implementation skill to build it. This skill's job ends at an exciting, high-volume, annotated list; name the handoff, then stop.

---

## Quality standards

**Volume comes from breadth of mechanism, never from padding.** Fifteen ideas means ~3 from each of 4–5 different mechanisms aimed at different regions — not 15 angles on one mechanism. If a batch is thinning out within one mechanism, switch mechanisms rather than stretching.

**Don't water down the mechanisms.** If a persona idea could have been generated without the persona, the lens isn't working. If a cross-domain idea doesn't use the domain's actual mechanisms, the seed isn't working. If a constraint idea could exist without the constraint, the constraint wasn't real. If the "random" seed was actually chosen to be convenient, it isn't random. Regenerate.

**Distance is the objective, every batch.** Before presenting an idea, check it against the archive: does it share a mechanism, assumption, or starting point with something already generated? If so, move off that dimension. Variations are not distinct ideas — "X using AI" and "X using AI but personalized" are one idea. At volume, light de-duplication within the batch before you present is part of the job; flag obvious near-twins rather than shipping both, but don't over-police to the point of pre-filtering on quality (principle 1).

**Honor the asymmetry.** Apply the Negative Bank ruthlessly: if a later idea echoes a reject or a no-go direction, discard it. Never steer toward keeps or stars — recording them is enough.

**Keep all judgment with the user.** Don't rank, score, defend, or pre-filter. Annotations describe what an idea opens, never how good it is.

**Be honest about the baseline and saturation.** If Claude would have generated a "non-median" idea by default, it belongs in the baseline. If a batch is filling up with cousins, say so rather than padding to hit 15 — a smaller honest batch beats fifteen near-duplicates. But flagging cousins is a cue to *break out* (fresh seeds, unused mechanisms), never a cue to suggest stopping; the stop-suggestion rule lives in Phase 5 and depends only on the user's keep rate.