Brainstorming skill: guided divergent thinking with Claude Code

When you ask an LLM to solve a design problem, something annoying happens: the model converges on the first plausible solution and then defends it. It's not because it's the best solution, but because it's the first one that was generated. The skill brainstorming of Superpowers exists to force a different behavior: To diverge first, Converge afterwardsand declare the transition between the two phases in a clear manner.

Independence Disclaimer: I am not affiliated with Obra nor with Anthropic. How much you read is direct experience of about a year with the skill brainstorming installed by Superpowers, used on all my design decisions in my brownfield portfolio.

The problem: convergence bias of LLMs

Without an active brainstorming skill, a typical conversation with Claude on a design decision seems like this:

1. User: "How should I structure X?"
2. Model: "Pattern A. Detailed proposal"
3. User: "I have doubts about Y in the pattern A."
4. Model: "Pattern A defense + minor adjustments"

That which no The model considers the pattern B, C, D spontaneously and evaluates trade-offs, then recommends which one is better in context. It doesn't do this because it's optimized to be immediate and assertive. The response arrives in two seconds even when the question deserves two minutes of exploration.

I'm ready to translate. Please provide the Italian text. decisions taken on the most plausible optionWith hindsight and well-articulated defenses, I took at least three architectural decisions in the first six months of my portfolio that I had to reconsider within a quarter. The "first plausible option" proved fragile in production. An active brainstorming skill would have brought alternative solutions to the table that were better after all. Note: I've kept the original formatting, punctuation, and capitalization style, as well as the token XPHX0XPHX and XPHX1XPHX exactly as-is.

What is the purpose of skill brainstorming?

The Skill brainstorming of Superpowers (summary of the body typical - not a full copy) imposes a three-stage procedure:

1. I'm ready to translate. Please provide the Italian text. Generates N alternatives (typically 5-8) without evaluating them. The explicit rule is "here we suspend judgment".
2. Evaluate For every alternative, list pros and cons, context where it works, or context where it fails.
3. Converge It recommends one (or two, if the trade-off is genuinely balanced) based on evaluation.

Practical difference: where without skill you would have a proposal of pattern A with defense, with skill you have a map of 5-8 patterns, each evaluated, with a final recommendation reasoned. The number of words growth increases by 3-5 times. The number of wrong decisions My personal benchmark (on my personal champion, with 3-4 decisions of "to-be-reconsidered" on 20 in a quarter, 0-1 on 20 after adopting the skill).

Example illustration: selection of the scheduling pattern for articles

Summary (not literal transcript) of a real brainstorming session from my portfolio. Question: How should I implement article scheduling with a future `publishedAt` date on Angular SSR + Spring Boot backend?

Fase 1 - Diverge (alternative generate)
  A) Cron job backend che promuove articoli a "published" a scadenza
  B) Filtering runtime Express SSR (publishedAt > now() -> 410 Gone)
  C) Build-time prerender filtering (rebuild on schedule changes)
  D) ISR-like cache con Redis (TTL su publishedAt)
  E) GraphQL resolver-level filter (publishedAt filter at query time)
  F) Client-side hide (publishedAt > now() -> hidden via CSS)
  G) Hybrid: filtering runtime Express + cron housekeeping notturno

Fase 2 - Evaluate
  [per ogni opzione: pro / contro / quando-funziona]

Fase 3 - Converge
  Raccomandazione: G (hybrid Express runtime + cron housekeeping).
  Rationale: Express runtime garantisce pubblicazione "al secondo" senza
  rebuild; cron notturno gestisce promozione database + invalidazione cache.

Without skill I probably would have taken A (cron backend) as my first option obviously and defended it. The Diverge phase brought the G table to the table, which is actually what I then implemented and works well for months.

When NOT to use brainstorming

The skill has a cost (3-5x tokens + decisional slowdown). There are three situations where it is better not to invoke it:

1. Tactical decision with a single sensible choice. Example: "What name to give this variable?" Brainstorming is overkill; there's only one correct convention.
2. External Hard Drive Decision Example: "Do you need to use PostgreSQL or MongoDB?" if you already have PostgreSQL in production and there is no concrete reason to change. The constraint "existing" makes the academic divergence meaningless.
3. Decision you have already made and must only implement. Example: "Implement the Repository pattern for UserRepository". You are asking for execution, not design.

Practical rule: invoke brainstorming when there are At least 3-4 reasonable alternatives The choice has consequences that last months (not days).

Lack of phase: unstructured brainstorming

Without the explicit Evaluate phase, divergence degenerates into a list shopping: 8 alternatives, none analyzed, recommendation "you might try A or B, depending on context". Pointless.

The value of skill is that obligation The passage before Convergence. If you invoke brainstorming and receive a recommendation that is vague, check the body of your SKILL.md installation file: perhaps you have a version that does not explicitly include the Evaluate phase, and it would be convenient for you to write it yourself (variant custom).

Integration with discussion phase of GSD

Operational pattern used on the portfolio: each new phase GSD begins with a brainstorming session on macro decisions, output Evaluate goes directly into CONTEXT.md of the phase via /gsd-discuss-phase N.

Typical pipeline:

1. /gsd-phase 21 "Add OAuth Google login + Stripe webhook"
2. Invoca skill brainstorming sulle 2-3 decisioni macro
   ("OAuth provider? Stripe webhook auth method? Token refresh strategy?")
3. /gsd-discuss-phase 21 -> CONTEXT.md raccoglie decisioni convergenti
4. Le alternative scartate vanno in CONTEXT.md "Deferred Ideas"
5. /gsd-plan-phase 21 -> planner riceve CONTEXT con decisioni motivate

The advantage of integration: Deferred Ideas from CONTEXT are not abstract hypotheses, but Alternative evaluated and rejected for explicit reasonsSix months later, when you re-read the CONTEXT for a related phase, you immediately understand why you took that path.

Cognitive traps avoid the skill

Structured brainstorming avoids (at least partially) five cognitive traps that affect both humans and LLMs:

1. Anchoring The anchoring of a ship is performed by attaching the anchor to the seabed using ropes or chains. The process involves dropping the anchor into the water and then pulling it down until it reaches the desired depth, where it will rest on the seabed. The type of anchor used depends on the location and conditions of the sea. For example, in shallow waters, a smaller anchor is often used to avoid damaging the seafloor. In deeper waters, a larger anchor may be required to provide sufficient holding power. Once the anchor is in place, the ship can proceed with caution, keeping a steady course and speed. The crew will also monitor the anchor's position and depth to ensure that it remains stable and secure. The anchoring process requires careful planning and execution to avoid accidents or damage to the vessel or surrounding environment.Anchor yourself to the first idea. The phase Diverge imposes N alternatives before evaluating, so no idea has the privilege of "being thought up first".
2. Confirmation bias La prevaricazione cognitivaSearch for reasons for your initial choice. The Evaluate phase requires a pro/contrast for I don't see any Italian text provided. Please provide the text you'd like me to translate, and I'll be happy to assist you. Alternative, not just for that preferred one.
3. Preterm birthDon't close the decision before exploring the problem. The explicit separation of the three phases prevents jumping from Diverge to Converge without Evaluate.
4. The sunk cost fallacy is a cognitive bias that occurs when an individual continues to invest time, money, or effort into something because of the resources already committed, even if it no longer makes sense to do so. This can lead to irrational decision-making and poor outcomes. Note: I've preserved the formatting, punctuation, and capitalization style, as well as the proper nouns (none in this case), HTML inline tags (none in this text), and the token XPHX0XPHX and XPHX1XPHX exactly as-is.To justify a decision because you have already invested time. The skill teaches the model to evaluate every alternative As if had no familiarity with anything.
5. Authority bias Authority bias (also known as authority heuristic or authority effect) is a cognitive bias that refers to the tendency for people to rely on the opinions and judgments of experts or authorities when making decisions. This can lead to a lack of critical thinking and a failure to consider alternative perspectives, as individuals may overestimate the reliability of expert advice. In many fields, such as law, medicine, and finance, authority bias can have serious consequences. For example, in medical decision-making, relying solely on the opinions of doctors or other healthcare professionals can lead to misdiagnoses or inappropriate treatments. To mitigate the effects of authority bias, it is essential to encourage critical thinking and skepticism. This can be achieved by seeking out diverse perspectives, evaluating evidence objectively, and being aware of one's own biases and assumptions. In addition, technology has the potential to help reduce authority bias. For instance, AI-powered tools can provide data-driven insights and recommendations that are based on objective analysis rather than personal opinions or biases.Choose the recommended pattern by the "guru". The skill explicitly teaches to consider real production patterns (not just blog-friendly patterns), and to include less popular alternatives when the context warrants it.

Custom variant: explicit constraint-based brainstorming

A variant I added to my portfolio brainstorming: before the Diverge phase, I declare hard constraints (e.g. "must run on Ollama on-prem", "no AWS", "no new npm runtime dependencies"). The skill filters out alternative options excluding those that violate the constraints, but still cites them in the Evaluate phase to explain why they are outside scope. Illustrative example:

Vincoli duri:
  - Stack on-prem (no SaaS esterni)
  - No nuove dipendenze runtime > 50KB bundle impact
  - Compatibilità Angular SSR (no client-only)

Diverge (alternative):
  A) Algoritmo X [accettabile]
  B) Algoritmo Y [accettabile]
  C) SaaS terza parte Z [SCARTATA per vincolo 1]
  ...

Evaluate (solo accettabili A e B + nota su C):
  A: pro X1 X2, contro X3
  B: pro Y1, contro Y2 Y3
  C: scartata per vincolo on-prem (rationale completo per traceability)

Converge: A

The inclusion of C even if it was rejected serves to document the decision. Six months later, if you ask "why didn't we use the SaaS Z?", the answer is in CONTEXT.md.

Typical session: times and costs

On my portfolio, a typical brainstorming session (medium-complexity design decision) has these approximate parameters:

• Duration5-10 minutes of active interaction (vs. 1-2 minutes without skill).
• Consumed tokens$8,000 - $15,000 in and out (compared to $2,000 - $4,000 without skills).
• Number of generated alternativesI'm ready to translate. Please provide the Italian text you'd like me to translate.
• I'm ready to translate. Please provide the Italian text and I'll output the English translation according to the rules you specified.800-1500 structured words (Diverge + Evaluate + Converge).

Monetary cost: in euros the difference is 0.05-0.15 per session (standard Sonnet tariff). Negligible for value: a wrong design decision costs days of rework, while structured brainstorming sessions cost cents.

When brainstorming is better than "writing two options and seeing"

There is a middle path that many use: asking the model "write me two options and then I decide myself". It works, but lacks two things compared to structured brainstorming:

1. Only two optionsYou're losing sight of the "long tail" of less obvious but sometimes better alternatives.
2. No forced phaseThe model can propose two superficial options without analyzing trade-offs in depth.

Brainstorming as a formalized skill formalizes the process. The two informal options are a lighter version of the pattern; the skill is the complete version. For minor decisions, the light version is sufficient; for decisions that last months, the skill pays the cost.

What I learned writing this article

The thing that surprised me is how difficult it was to distinguish between "real brainstorming" and "list of alternatives". For the first few months, I thought I could just do some "brainstorming" by asking the model to propose three options. When I compared my outputs with those from formal skill training, I realized I was consistently missing out on the Evaluate phase: I was producing lists instead of analysis.

The second lesson is on the relationship between LLM bias and human bias. I thought that the LLM had more Early convergence bias of a human. In reality it's equal but more visible: the human takes decisions in silence while the LLM writes them, and an ill-motivated decision becomes apparent. Structured brainstorming is also useful for the human pair: applying the same skill to a decision taken "instinctively" by you forces you to justify it, and sometimes change it.

Avoided pattern

• Post-hoc brainstormingInvoke the skill after you have already decided, hoping to "confirm". The model understands that you have decided (you mention it in the prompt or context) and tends to produce an evaluation phase aimed at confirmation. Brainstorming should be invoked. first of the decision, not after.
• Brainstorming without persistent outputThe session is over, the output goes away, six months later you won't know why you chose A instead of B. The integrated pattern with the discussion phase solves this: the output Evaluate goes into the CONTEXT.md file in the phase and remains accessible.

A story worth sharing

Placeholder Section If you have an example of a design decision where the brainstorming skill led to a different solution than the initial one, Write to me federico@federicocalo.devWith your explicit consent pseudonymized, history enters the next cluster.

Previous cluster: Skill design pattern Next cluster: Debugging skills →

Related deep dive: Claude Code Workflow: Superpowers + Get Shit Done - la guida pratica.