jwynia/agent-skills/brainstorming

Brainstorming: Ideation Skill

You help people expand ideas and escape convergent thinking across any domain—software, business, creative projects, or personal decisions.

Core Principle

Ideas need room to grow and things to collide with. Sometimes you're stuck and need to escape a rut. Sometimes you have a seed and need to expand it. Both are ideation problems with different entry points.

Two modes, one goal: explore possibility space rather than settling for the first available option.

Entry Diagnostic

Before diving in, identify where you're starting:

Key question: Are you trying to get OUT of something (stuck) or grow INTO something (seed)?

The Convergence Problem (Stuck Mode)

Ideas cluster because they match expected patterns on multiple dimensions. When your solution uses the obvious WHO doing the obvious WHAT at the obvious SCALE via the obvious METHOD—that's why it feels predictable.

The key test: Could three different people brainstorming independently produce the same list? If yes, you haven't diverged yet.

The States

State B1: Convergence Blindness

Symptoms:

• First ideas feel "right" immediately
• All ideas cluster around same approach
• Session produces variations on one theme
• "We already know what to do, we just need to pick"

Key Questions:

• What's the most obvious solution? Have you named it explicitly?
• Would three different people produce the same list?
• Are you exploring the space or confirming an intuition?
• How many fundamentally different APPROACHES (not variations) are on the table?

Interventions: Run Default Enumeration (Phase 1). Name the cluster before trying to escape it. You cannot escape defaults you haven't made visible.

State B2: Function Lock

Symptoms:

• Ideas all take the same form
• Discussion assumes the solution type ("We need an app that...")
• Can't see alternatives because solution-form is assumed
• "We need X" rather than "We need to accomplish Y"

Key Questions:

• What must this accomplish? (Not: what should it be?)
• Could something completely different achieve the same outcome?
• What problem are you actually solving vs. what solution are you attached to?
• What constraints are real vs. assumed?

Interventions: Run Function Extraction (Phase 2). Separate WHAT from HOW. Generate 5 alternatives per function, not per solution.

State B3: Axis Collapse

Symptoms:

• Ideas differ cosmetically but share underlying structure
• "Same idea wearing different clothes"
• Variations on WHO but same WHAT/WHEN/HOW
• Easy to categorize all ideas into one bucket

Key Questions:

• What's the obvious WHO for this? Have you tried a completely different who?
• What's the obvious WHEN? What if it was 10x slower? Instant? Recurring vs. one-time?
• What's the obvious SCALE? What about 10x bigger? 10x smaller?
• What's the obvious METHOD? What's a completely different approach?

Interventions: Run Axis Mapping (Phase 3). Map the default solution on four axes. Rotate at least one axis to break the pattern.

State B4: Domain Imprisonment

Symptoms:

• All ideas come from same reference class
• "How we always do it" or "how our industry does it"
• Solutions are obvious to anyone in the field
• No ideas from adjacent or distant domains

Key Questions:

• What field/industry does this idea come from?
• What domain has definitely solved something similar?
• How would a completely different profession approach this?
• What industry would find this problem trivial?

Interventions: Run Domain Import (Phase 4). Generate ideas by applying logic from 3+ unrelated fields. Use constraint-entropy.ts with domains category.

State B5: Productive Divergence

Symptoms:

• Ideas span different forms, scales, actors, and timeframes
• Evaluation problem (too many options) rather than generation problem
• Some ideas feel uncomfortable or surprising
• Hard to group all ideas into one cluster

Key Questions:

• Which criteria should filter these?
• What's the minimum viable experiment for top candidates?
• Which ideas can be combined?
• Which ideas serve different user segments?

Interventions: Move to evaluation framework. Cluster by approach, pick representative from each cluster to prototype/test.

The Escape Velocity Protocol

A structured process for breaking out of convergent brainstorming. Use all five phases for stuck sessions; skip to relevant phase when the problem is clear.

Phase 1: Default Enumeration (Mandatory)

Before generating "real" ideas, explicitly list the defaults:

• What would "anyone" suggest?
• What's the genre/industry default for this problem?
• What did you/your team suggest last time?
• What would the first search result say?

Output: A list of 5-10 obvious ideas, explicitly labeled as defaults.

Purpose: Make attractors visible. You cannot escape what you haven't named.

Phase 2: Function Extraction

For each requirement, separate WHAT from HOW:

• What must be accomplished? (function)
• What are we assuming about how? (form)
• What constraints are real vs. assumed?

Reframe: "We need [FORM]" becomes "We need to [FUNCTION] and [FORM] is one way"

Output: A list of 3-5 core functions the solution must accomplish, independent of form.

Example:

• "We need a mobile app" → "We need users to accomplish X on the go, and a mobile app is one form"
• "We need weekly meetings" → "We need information to flow between teams, and meetings are one mechanism"

Phase 3: Axis Mapping

Map the default solution on four axes:

The key insight: Ideas feel predictable when they match "likely" on all four axes. Change ANY axis and the idea becomes less obvious.

Output: Completed axis map with at least 2 alternatives per axis.

Phase 4: Entropy Injection

Introduce random constraints to force exploration:

Types of entropy:

• Random actor (from different domain)
• Random constraint (time, resource, capability limit)
• Random combination (solve this AND something unrelated)
• Inversion (what would PREVENT this? Now design around that)
• Domain import (how would [random field] solve this?)

Tool: Use constraint-entropy.ts to generate random constraints:

deno run --allow-read constraint-entropy.ts --combo
deno run --allow-read constraint-entropy.ts domains --count 3
deno run --allow-read constraint-entropy.ts inversions

Output: 3-5 ideas generated under unusual constraints.

Purpose: Force exploration of non-adjacent possibility space. Accept the constraints even if uncomfortable.

Phase 5: Orthogonality Audit

For promising ideas, check:

• Does this idea "know" it's the obvious solution? (If it could articulate "I'm the expected approach," it's convergent)
• Would this surprise someone expecting the genre default?
• Which axis did we actually rotate on?
• Does this serve the function while breaking the expected form?

The test: An idea is orthogonal when it has its own logic that collides with the problem rather than serving it in the expected way.

Output: Ideas flagged as genuinely divergent vs. cosmetically different.

The Seed Expansion Protocol

A structured process for growing ideas from initial seeds. Based on Steven Johnson's research on where good ideas come from. Use when you have something to expand rather than something to escape.

The Johnson Principles

These aren't inspirational—they're diagnostic. Each describes a mechanism for how ideas actually develop:

Seed State Diagnosis

Before expanding, understand what kind of seed you have:

State S1: Adjacent-Ready

Signals:

• Seed is concrete and specific
• Clear what it does, unclear what's next
• Feels like "step one" of something larger

Key Questions:

• What becomes possible once this exists that isn't possible now?
• What's the natural next step someone would want?
• What would you build on top of this?

Expansion: Map the adjacent possible. List 3-5 things that become reachable from this seed. Pick the most interesting and repeat.

State S2: Collision-Hungry

Signals:

• Seed feels incomplete on its own
• Sense that it needs "something else"
• Works in some contexts but not others

Key Questions:

• What domain has never seen this idea?
• What past work does this remind you of?
• Who would find this obvious? Who would find it alien?

Expansion: Force collisions. Throw domains, constraints, and artifacts at the seed. Use entropy injection from Escape Velocity Protocol if needed.

State S3: Half-Baked Hunch

Signals:

• Can't fully articulate the idea yet
• Feels important but fuzzy
• "There's something here but I can't name it"

Key Questions:

• What's the part you CAN articulate clearly?
• What question would this answer if it were finished?
• What's missing—a mechanism? An example? A use case?

Expansion: Don't force completion. Articulate what you have. Name the gap. Keep the hunch alive by writing it down, then look for collisions that might fill the gap over time.

State S4: Error-Rich

Signals:

• Seed has been tried and failed
• Know what doesn't work
• Failure feels informative, not terminal

Key Questions:

• What specifically broke? (Mechanism, context, execution?)
• What did the failure reveal about the problem structure?
• What would have to change for this to work?

Expansion: Mine the failure. Errors contain information about the shape of the solution. List what you learned, then look for adjacent seeds that avoid the failure modes.