Diverge — Divergent Option-Generation Engine

Break premature convergence. Autoregressive reasoning commits to the first plausible answer; this skill manufactures genuine breadth before any evaluation, then converges deliberately.

Core principle: Separate generation from judgment. Ideas are generated in ISOLATION (no branch sees another, so none can anchor on another), and only a SEPARATE critic pass is allowed to evaluate. Evaluating while generating is the failure mode this skill exists to prevent.

Pre-Flight Gate

Activation is decided by the frontmatter description alone — this file is read only AFTER the skill has been selected. Nothing here can prevent over-triggering, so this gate is a post-selection redirect, not a filter.

Before proceeding, check the ABORT conditions below. If any holds, STOP, say in one line which one fired, and take the redirect instead of fanning out any agents. Being invoked — including a literal /diverge, "brainstorm options", "explore alternatives", or "give me alternatives" — does NOT override an ABORT: the phrasing that selected this skill is not evidence the problem is open.

PROCEED only when no ABORT fired AND consequence × openness both hold — hard to reverse, wide blast radius, or high cost of being wrong, AND several viable, structurally different approaches plausibly exist. The gate is consequence × openness, NOT token cost.

Phase 1: DIVERGE — Isolated Parallel Generation

1. Restate the problem in one sentence and list the hard constraints (these go to every frame).
2. Pick ~5 frames from the table below whose vantage best surfaces structurally different approaches for THIS problem. Use 4 for narrow problems, up to 6–7 for wide ones. More than 7 hits diminishing returns (see multi-agent-orchestration).
3. Send a single message with multiple Agent tool calls for parallel agent launches — one Agent per frame, all in the same message. Each runs in isolation and never sees the others.
4. Give every sub-agent the SAME generator-only instruction:

You are a GENERATOR working under the "<FRAME>" frame. From this vantage only: PROBLEM: <one-sentence problem> CONSTRAINTS: <hard constraints> Produce 3–5 genuinely distinct approaches. For each: a one-line name, the core idea (2–3 sentences), and the single biggest risk. RULES: Do NOT evaluate, rank, hedge, or pick a winner. Do NOT mention other frames or approaches (you cannot see them). Favor range over safety — at least one approach must be non-obvious. Output a flat list. No preamble.

Isolation invariant: No generator receives another's output. No generator is asked to compare, score, or choose. Violating this re-introduces the anchoring the skill exists to remove.

Gate: All frame agents returned. You hold a flat, unscored, un-deduplicated pool. No evaluation has happened yet.

Phase 2: FOCUS — Separate Critic Pass

Only now is judgment allowed. Do this yourself (or one critic agent) over the WHOLE pool.

1. Score each approach 1–5 on three axes, then weighted total: score = 0.25·novelty + 0.45·viability + 0.30·fit (novelty = distance from the obvious default; viability = buildable under constraints; fit = serves the real goal)
2. Flag traps — high-novelty/seductive approaches that fail a hard constraint. List each with the SPECIFIC constraint it violates. Traps are reported, never silently dropped.
3. Cluster survivors by underlying angle (collapse near-duplicates from different frames; note where isolated frames converged — that convergence is signal).
4. Deepen the top 3 by weighted score: mechanism, key trade-off, first failure it would hit, rough cost/effort.

Gate: Every approach scored; traps flagged with reasons; clusters formed; top 3 deepened.

Output Shape

1. Brief — one line: the problem and the constraints that bind it.
2. Wide set — full pool as a flat list, each with a chip [N x.x | V x.x | F x.x → total].
3. Converge — shortlist — top 3, with the single best non-obvious pick STARRED (★) and one line on why it beats the obvious default. List traps separately below, each with the constraint it violates.
4. Deepened branches — the mechanism/trade-off/first-failure/cost for the top 3.
5. One provocation — a single closing line: the assumption most worth challenging, or the next option if constraints loosened. Exactly one.

Anti-Patterns

Integration with Other Skills

/diverge is the divergent complement to the convergent /deep-analysis.

Hand-off chain: /diverge (widen) → pick winners → /deep-analysis (validate) → /execute (build). Never feed the raw wide set to /execute; converge first.

Cost Note

The Diverge phase spends ~5 parallel sub-agents plus one critic pass — real but bounded. Justified ONLY by the pre-flight gate (consequence × openness), never by default. On a closed or low-stakes problem this skill is WRONG, not merely expensive: it manufactures noise and false choices.

Frames Table

References

• anti-anchoring rule — the always-on inline habit this skill is the heavy mode for
• deep-analysis skill — the convergent partner; validates the chosen winner
• multi-agent-orchestration skill — parallel-launch idiom; 5–7-agent diminishing-returns limit
• execute skill — builds the converged winners