How I Taught Claude to Brainstorm (By Asking It What It Actually Needs)

If you’ve used Claude Code for any serious work, you’ve probably come across superpowers. It’s a plugin that gives your coding agent a structured workflow, and one of its core skills is brainstorming. Before you write code, it walks you through a Socratic loop: one question at a time, propose two or three approaches, weigh trade-offs, validate. It’s well-designed. I used it for weeks.

The problem is that superpowers is a process tool, not a thinking tool. It structures the conversation but doesn’t change how the model reasons. The output quality is bounded by whatever Claude would have generated anyway, just organized more neatly.

I kept noticing the same pattern. Ask Claude to brainstorm ten solutions and you get ten variations on two or three underlying concepts. The list looks comprehensive. It isn’t. The ideas are semantically clustered, dressed up as diversity. No external plugin I could find addressed this because no external plugin touched how Claude actually thinks.

So I decided to start from the research instead of someone else’s workflow.

#832 Sources, 150 Methods, Zero Filters

The starting point was a deep research session. I asked Claude to survey the entire landscape of brainstorming methods, mental models, and cognitive techniques. Not a quick search. A proper literature review. 832 sources. 1 hour and 12 minutes. The output: a catalog of over 150 distinct methods organized into eight families, from Osborn’s 1953 brainstorming rules through De Bono’s lateral thinking, TRIZ, biomimicry, all the way to neuroscience-informed techniques around default mode network activation. Every major approach to creative cognition documented in the research.

I dropped that catalog into a Claude Code session and asked: is this enough to build a brainstorming plugin? Claude’s response was direct: “The challenge is the opposite: we need to curate aggressively. A skill with 150 methods would be unusable.”

The initial cut was straightforward. Roughly 40% of the catalog involves body-dependent, time-dependent, or unconscious-processing techniques. Flow states require a body. Sleep incubation requires sleep. Embodied cognition requires walking. The Gallery Method requires multiple humans in a room. None of that translates to a language model.

What survived: structured frameworks, question-based methods, mental models, and creative ideation techniques that work through language and logic. Still dozens of candidates. Too many to be useful.

To fill the gaps on the AI side, I dispatched research agents to investigate two specific questions: which structured reasoning patterns (chain-of-thought, tree-of-thought, self-consistency) actually improve LLM output quality, and what the empirical research says about LLM failure modes during creative tasks. Twenty research files came back.

#What the Research Actually Found

The research painted a specific picture. Not “LLMs are bad at creativity.” Something more precise and more actionable.

LLMs have a characteristic failure profile in brainstorming, and it’s systematic, not random.

GPT-4 scores in the top 1% on the Torrance Tests of Creative Thinking for fluency and originality. That sounds impressive. But a study of 758 employees told the other side of the story: individuals using GPT-4 produced more ideas, while the collective conceptual variation across participants went down. Different people asking the same model for ideas get similar ideas back. Individual fluency up, collective diversity down. The researchers call this the homogenization paradox.

The divergent/convergent research explained the mechanism. Human creativity researchers have known since Guilford in 1967 that effective creative thinking requires separating two phases: divergent thinking (generating many options freely) and convergent thinking (narrowing to the best one). Mix them and you kill creative output. This is Osborn’s original “defer judgment” rule from 1953, validated repeatedly ever since.

LLMs violate this separation by default. RLHF training rewards “complete, satisfying” responses. The model learns to generate and self-evaluate simultaneously. There is no structural opportunity for a bad first draft. Every idea passes an internal quality filter before you see it. The result: safe, moderate ideas that are neither wildly creative nor deeply refined. An unhelpful middle ground.

Four mechanisms drive this: training signal conflation (creativity and correctness are rewarded jointly), single-turn response pressure (no room for a rough draft), self-consistency pressure (each token constrains the next), and sycophantic convergence (gravitating toward what the user seems to want).

#Most of Those 150 Methods Were Useless

Armed with 20 research files, a 150-method catalog, and a much clearer picture of the actual failure modes, I pushed back on the scope.

“Introspect deeply. Revise, what would you cut. What would you use. After all you have to use it then.”

Claude’s response was the most interesting moment in the entire session.

“Most of those 150+ methods are useless to me. The AI reasoning patterns (CoT, ToT, GoT, ReAct, Reflexion, Self-Refine) — that’s how I already think. Teaching me CoT is like teaching a human to use neurons. I don’t need a skill to tell me to reason step by step. What I actually need are methods that counteract my specific biases.”

Then it produced a table. Each row: a named bias, what happens when the bias kicks in, and the method that fights it.

Bias	What Happens	Counteracting Method
Premature convergence	Jumps to “the answer” without exploring	Diverge-then-Converge
Sycophancy	Leans toward what the user wants	Inversion / Pre-Mortem
Mode collapse	”Different” ideas are variations of the same idea	Constraint Manipulation
Shallow exploration	Stays in the obvious neighborhood	First Principles Decomposition
Authority bias	Defaults to best practices	Assumption Surfacing
Single perspective	Thinks only as “helpful assistant”	Perspective Forcing
Local search	Explores only adjacent solutions	Analogy Search
Vague decomposition	Overlapping, incomplete breakdowns	MECE Decomposition

“That’s 6-8 core methods. Not 150. Not 80. Eight.”

The framing shift was the real insight. These aren’t “good brainstorming methods.” They’re bias-countermeasures. Each one exists in the plugin because it fights a specific, named failure mode that the research documents. The selection criterion was never “which methods are most popular” or “which methods are most creative.” It was: which methods correct for the ways I predictably fail.

#Why Fresh Agents

The plugin has two modes. For a quick design decision, Claude applies the methods inline: pick the right ones based on the problem type, work through them sequentially. For high-stakes or ambiguous problems, it spawns four parallel subagents, each assigned a different pair of methods. Agent 1 gets First Principles and Assumption Surfacing. Agent 2 gets Inversion and Perspective Forcing. Agent 3 gets Analogy Search and Constraint Manipulation. Agent 4 gets MECE and Diverge-then-Converge. They explore independently, then the main conversation synthesizes.

The reason for fresh agents is not about compute or parallelism. It’s about context. A fresh agent has no prior conversation anchoring its thinking. In brainstorming specifically, this matters. A subagent that hasn’t heard your three previous ideas about the problem won’t be nudged toward them. Sycophancy and anchoring are context-dependent biases. Strip the context and you reduce both. The subagents aren’t better reasoners. They’re less anchored ones.

The first time I used the plugin on a real problem, I asked it to brainstorm a color palette for my personal brand. The inline version produced a solid five-method analysis: first principles on what colors actually do for a consulting brand, analogy search across architecture firms and premium product brands, inversion on what would make the brand forgettable. Good output. Then I reran it with parallel subagents. Three of four agents, working independently, converged on the same surprise: the palette needed a strong light-mode variant because dark-on-dark looks like every other tech brand and falls apart on projectors. Nobody had asked about light mode. Three independent agents found it anyway. That’s the kind of finding that inline brainstorming, anchored in the conversation’s existing direction, tends to miss. (That color palette story is becoming its own post.)

#What It Looks Like in Practice

Every brainstorming session produces the same structure: problem restatement, labeled method sections showing each method’s actual findings, a convergence analysis (where methods agree, where they disagree, and what surprised), a concrete recommendation with trade-offs, and open questions.

The final artifact: 15 files. One skill with eight method references, two worked examples, one command, one subagent definition, one hook. 150 methods became 8 reference files. The selection matrix maps problem types to starting methods: “How should I design X?” starts with First Principles and MECE. “I’m stuck on X” starts with Assumption Surfacing and Constraint Manipulation. “What could go wrong?” starts with Inversion and Perspective Forcing.

It works noticeably better than what I had before. Not because the methods are exotic. First principles, inversion, analogy search: none of these are new. What’s new is the framing. When every method exists to counteract a named bias, the model doesn’t just apply the method. It knows what it’s correcting for. That changes the output.

#The Plugin

The brainstorming plugin is part of fractional-cto, a Claude Code plugin collection. If you brainstorm with Claude and find the output comprehensive but shallow, this is the fix I built. Credit to superpowers for the starting point.