# Heavy Think

> Unified heavy thinking orchestrator. Classifies problem type → dispatches to the right parallel thinking pattern. Modes: brainstorm (divergent ideation — solo agents or a collaborative team 'council'), solve (verifiable answers), decompose (break complex problems), unstick (reframe blockages), debate (live agent-team debate — named teammates argue with each other via SendMessage, then YOU synthesize). All modes use parallel agents/teammates with model=opus for maximum reasoning depth, then YOU synthesize. Teammates vs subagents: use agent-team teammates when the agents need to talk to each other (debate, collaborative brainstorm, hand-offs); use parallel subagents when they don't (independent fan-out). Actions: think deeply, brainstorm, council, decompose, solve, unstick, analyze, debate. Keywords: heavy think, heavy thinking, think harder, brainstorm, council, collaborative brainstorm, brainstorm together, build on ideas, expand ideas, ideate together, decompose, break down, stuck, unstick, solve, debate, de

- Skill: `samhvw8/heavy-think` (Agent Skill, multi-file: 11 files)
- Install (CLI): `npx skillmds@latest add samhvw8/heavy-think`
- Raw SKILL.md: https://api.skillmd.com/api/skills/samhvw8/heavy-think/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: samhvw8 (https://skillmd.com/u/samhvw8)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/samhvw8/heavy-think

---


# Heavy Think

Unified orchestrator for heavy thinking. One entry point, four modes — all powered by parallel agents → your synthesis.

**Core principle:** the parallel-agents-→-synthesize pattern is general-purpose. Change what the agents explore, and you get different thinking capabilities from the same engine.

**Teammates vs subagents:** *Use teammates (agent teams) when the agents need to talk to each other — debate, collaborative brainstorm, hand-offs. Use parallel subagents when they don't — independent fan-out.* Teammates compound (live cross-talk) but cost more and require the **main session** + `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`; subagents are cheaper and collide only once, in your synthesis.

## Dispatch

Classify the problem, pick the mode:

| Signal | Mode | Pattern |
|--------|------|---------|
| "What should we..." / "What are the options" / subjective question | **Brainstorm** | Parallel perspectives → collide → synthesize |
| Verifiable answer exists (math, logic, algorithm) | **Solve** | Parallel solution paths → deliberate → verify |
| "How do we break this down" / too big to tackle | **Decompose** | Parallel decomposition strategies → synthesize best structure |
| "I'm stuck" / every option feels wrong / going in circles | **Unstick** | Parallel reframes → find the frame that unlocks movement |
| "Debate this" / "pressure-test" / "argue both sides" / high-stakes call needing adversarial rigor | **Debate** | Named teammates argue live via `SendMessage` → you moderate → synthesize |
| Need step-by-step with revision capability | **Analyze** | Sequential thinking (no agents needed) |

When the signal is **Debate** (user explicitly asks to debate/pressure-test, or stakes are high), go straight to [Escalation: Agent Debate](#escalation-agent-debate) and run the **Team Debate** protocol — don't simulate it inline. Requires the main session (a subagent can't spawn teammates). Debate is also reached automatically when synthesis hits irreconcilable positions.

When uncertain: **ask the user** which mode fits. Don't guess.

When modes should chain: decompose first → brainstorm on each piece, or unstick → then solve.

---

## Mode 1: Brainstorm

Parallel perspective agents explore the same problem from different worldviews. Insight emerges from collision, not consensus.

### Stage 1: Frame

```
PROBLEM: [One sentence — what are we trying to figure out?]
CONSTRAINTS: [What's fixed? Budget, timeline, team size, tech stack...]
SUCCESS LOOKS LIKE: [How will we know a good answer when we see it?]
MODE: scan (3 agents, breadth-first) | deep (3-5 agents, depth-first)
```

### Stage 2: Design Perspectives

Choose 3-5 perspectives that **collide productively** — tension, not redundancy.

| Perspective | Explores |
|-------------|----------|
| First Principles | What's actually true vs assumed? |
| User Advocate | What does the person experiencing this actually need? |
| Contrarian | What if the obvious answer is wrong? |
| Futurist | What's true in 3 years that isn't today? |
| Operator | What breaks at scale? Maintenance burden? |
| Economist | Incentives? Who pays, who benefits? |
| Minimalist | 10% effort that captures 80% value? |
| Historian | What's been tried? Why did it fail/succeed? |

Rules: MUST include ≥1 challenger. MUST span ≥2 of: user, business, technical, temporal.

See `references/perspective-combinations.md` for pre-built sets by scenario.

### Stage 3: Spawn Parallel Agents

Launch all in **one message**, `model="opus"`. Each gets the same problem, distinct lens.

See `references/brainstorm-agent-prompt.md` for full prompt. Core structure:

```
You are a brainstorming agent exploring from one specific perspective.

PROBLEM: {problem} | CONSTRAINTS: {constraints}
YOUR PERSPECTIVE: {perspective_name} — {perspective_description}

Think from this perspective ONLY. Find what ONLY this lens reveals.

1. Challenge 2-3 assumptions most people take for granted
2. What is the REAL problem underneath the stated one?
3. Generate 3-5 ideas — push past the obvious first answer
4. Pick strongest. Stress-test: what breaks? what scales?
5. Second-order effects: if this succeeds, then what? And then what?

Output: ## Core Insight → ## The Real Problem → ## Ideas → ## Second-Order Effects → ## Hidden Risk → ## Provocation
```

### Stage 4: Synthesize (YOU — never delegate)

1. **Map** — territory each perspective covered, overlap vs divergence
2. **Collide** — where perspectives directly contradict (deepest insight lives here)
3. **Extract surprises** — what exists in NO single output but emerges from combining
4. **Second-order cascade** — trace strongest ideas: then what? and then what?
5. **Converge** — landscape → key insights (ranked by surprise) → tensions worth holding → recommendation → what to kill

### Stage 5 (Optional): Stress Test

For high stakes, spawn 1-2 agents to attack synthesis: Red team ("find every way this fails") or Pre-mortem ("it's 1 year later and this failed — what happened?"). See `references/brainstorm-agent-prompt.md` for templates.

### Escalation: Team Brainstorm (collaborative teammates)

Stages 1–5 use **isolated** parallel agents — they collide once, in your synthesis. When you want ideas to *compound* (each builds on the others live), escalate to a collaborative **council**: named teammates that cross-pollinate via `SendMessage`, then YOU harvest the expanded set. (Per the teammates-vs-subagents heuristic above — agents that build on each other need to talk.)

Full protocol, spawn template, anti-groupthink rules, and variants: **`references/team-brainstorm.md`**. Adversarial counterpart: `references/team-debate.md`.

---

## Mode 2: Solve

K independent agents solve the same verifiable problem from scratch. Deliberation audits reasoning chains and forges new paths from fragments — it produces correct answers absent from ALL trajectories in ~50% of cases.

### When to use

- Mathematical reasoning, algorithmic/competition problems, complex logical deduction
- Any verifiable task where confidence < ~70%
- NOT for subjective, preference-oriented, or easy (>90% confidence) tasks

### Stage 1: Parallel Reasoning

Spawn **K independent agents** in a **single message** (parallel). Zero sibling knowledge.

| K | When |
|---|------|
| 3 | Standard — most problems |
| 5 | High-stakes — competition math, critical correctness |

```
Solve this problem step by step. Show complete reasoning and arrive at a final answer.
Use whatever approach you find most natural — algebraic, geometric, constructive, brute force, or proof by contradiction.

Problem: {query}

Requirements:
- Reason from first principles, show all work
- Final answer clearly marked
- Math: \boxed{answer} | Code: code block
```

### Stage 2: Memory Cache

1. **Collect** all K outputs
2. **Shuffle** trajectory order (prevents position bias)
3. **Prune** if exceeding token budget — truncate reasoning, preserve final answers

### Stage 3: Sequential Deliberation (YOU — never delegate)

1. **Classify** query type (math / code / logic / multi-step)
2. **Map answer distribution** — what answers appear, how often?
3. **Audit each chain** — logic valid? gaps? sign errors? hidden assumptions?
4. **Cross-validate** — do independent approaches confirm the same result?
5. **Apply critical skepticism:**
   - Majority is signal, not proof
   - Minority answer with tighter logic may be correct
   - All may be wrong — re-derive from fragments if needed
6. **Synthesize** the definitive answer

### Stage 4: Output

Final answer only — no meta-analysis unless asked. Math: `\boxed{answer}` | Code: code block.

### Iterative Deliberation

Trigger when first deliberation produces low confidence or fundamental disagreement. Concatenate deliberation as additional trajectory, re-run Stage 3. **Max 2-3 iterations** — performance degrades beyond that.

See `references/compute.md` for cost analysis and K selection. See `references/tensions.md` for design tensions.

---

## Mode 3: Decompose

Parallel agents each decompose the problem using a **different decomposition strategy**. You synthesize the best structure from their outputs.

### Stage 1: Frame

```
PROBLEM: [What needs to be decomposed?]
WHY DECOMPOSITION IS HARD: [What makes this non-obvious to break down?]
GOAL: [What does a good decomposition enable? Parallel work? Clarity? Prioritization?]
```

### Stage 2: Spawn 3 Decomposition Agents

Launch all in **one message**, `model="opus"`:

| Agent | Strategy | Prompt Focus |
|-------|----------|--------------|
| Functional | By capability/responsibility | "What are the distinct functional areas?" |
| Temporal | By sequence/dependency | "What must happen first, second, third?" |
| Risk | By uncertainty/difficulty | "What's known vs unknown? Easy vs hard?" |

For deeply technical problems, swap in:
| Agent | Strategy | Prompt Focus |
|-------|----------|--------------|
| Data-flow | By information movement | "What data flows where? Where are the boundaries?" |
| User-journey | By user experience | "What does the user do step by step?" |
| Failure-mode | By what can go wrong | "What are the independent failure domains?" |

**Agent prompt template** (see `references/decompose-prompt.md`):

```
You are a decomposition agent. Break down a complex problem using a specific strategy.

PROBLEM: {problem}
CONTEXT: {context}
YOUR STRATEGY: {strategy_name} — {strategy_description}

Decompose this problem using ONLY your assigned strategy. Don't try to be comprehensive — show what your lens uniquely reveals about the problem's structure.

Requirements:
1. Identify 3-7 components/phases/pieces
2. For each: name it, define its scope, identify its inputs/outputs/dependencies
3. Flag which pieces are independent (parallelizable) vs sequential
4. Identify the hardest piece and explain why
5. Name what your decomposition MISSES — what falls between the cracks?

Output:

## Decomposition ({strategy_name})

### Components
1. **[Name]** — [Scope]. Inputs: [X]. Outputs: [Y]. Dependencies: [Z].
2. ...

### Dependency Map
[Which pieces depend on which? What can run in parallel?]

### Hardest Piece
[Which component and why — complexity, unknowns, risk]

### Blind Spots
[What does this decomposition miss or awkwardly split?]
```

### Stage 3: Synthesize

You compare all decompositions yourself:

1. **Overlay** — where do all strategies agree on boundaries? Those are real seams.
2. **Conflict** — where do strategies split things differently? These reveal design decisions, not facts.
3. **Blind spots** — what did each strategy miss? The union of blind spots shows hidden complexity.
4. **Compose** — build the final decomposition by stealing the best cuts from each strategy.

Output:
```
## Synthesized Decomposition

### Components (with source)
1. **[Name]** — [Scope]. Source: [which strategy revealed this most clearly]
2. ...

### Execution Order
[What's parallel, what's sequential, what's the critical path]

### Key Design Decisions
[Where decomposition strategies disagreed — and which cut you chose and why]

### Hidden Complexity
[What emerged from combining decompositions that no single one showed]
```

---

## Mode 4: Unstick

Parallel agents each **reframe the problem** from a different angle. The goal: find the frame that transforms "stuck" into "obvious next step."

### Stage 1: Name the Stuckness

```
PROBLEM: [What are you trying to do?]
WHY STUCK: [What's blocking? Every option feels wrong? Going in circles? Can't see the next step?]
WHAT YOU'VE TRIED: [What approaches have been attempted or considered?]
```

### Stage 2: Spawn 3 Reframe Agents

Launch all in **one message**, `model="opus"`:

| Agent | Reframe Strategy |
|-------|-----------------|
| Inversion | "What if the opposite of your assumption is true?" |
| Abstraction Shift | "What if you're solving the wrong level of the problem? Go up one level or down one level." |
| Constraint Flip | "What if the thing you think is fixed is actually variable, and vice versa?" |

For deeper stuck-ness, add:
| Agent | Reframe Strategy |
|-------|-----------------|
| Adjacent Domain | "What field outside yours has solved an analogous problem?" |
| First Principles | "Strip everything away — what's actually, provably true here?" |

**Agent prompt template** (see `references/unstick-prompt.md`):

```
You are an unsticking agent. Someone is stuck on a problem. Your job: reframe it so movement becomes possible.

PROBLEM: {problem}
WHY THEY'RE STUCK: {stuck_reason}
WHAT THEY'VE TRIED: {attempts}
YOUR REFRAME STRATEGY: {strategy_name} — {strategy_description}

You are not solving the problem. You are changing how they SEE it. A good reframe makes the next step obvious.

Requirements:
1. Name the assumption or frame that's creating the stuckness
2. Apply your reframe strategy to shift it
3. Show what the problem looks like after reframing
4. Suggest 1-2 concrete next steps that are obvious in the new frame
5. Name the risk of your reframe — what does it miss or oversimplify?

Output:

## The Trap
[What assumption/frame is keeping them stuck?]

## The Reframe
[Apply your strategy — how does the problem change?]

## After Reframing
[Describe the problem in the new frame. What's now obvious?]

## Next Steps
[1-2 concrete actions that follow naturally from the new frame]

## Reframe Risk
[What does this new frame miss or distort?]
```

### Stage 3: Synthesize

1. **Which reframe unlocks movement?** — Not which is cleverest, but which makes the next step most obvious.
2. **Can reframes combine?** — Sometimes two reframes together reveal more than either alone.
3. **What's the actual trap?** — If multiple agents identified the same underlying assumption, that's the real blockage.
4. **Recommend** — state the reframe that works, the next concrete step, and what to watch out for.

---

## Mode 5: Analyze

No agents needed — apply `sequential-thinking` skill directly.

Use when the problem needs step-by-step decomposition with revision capability, not parallel exploration.

Invoke: `Skill("sequential-thinking")`

---

## Escalation: Agent Debate

When standard parallel → synthesize isn't deep enough (low confidence, fundamental disagreements, high stakes), escalate to a **debate** — positions get attacked, and only what survives is kept.

### When to Escalate

- Synthesis reveals irreconcilable positions (not just different angles — genuine contradictions)
- Stakes are high enough to justify 3-5x more compute
- First-pass synthesis confidence is low
- User asks for "deeper", "more rigorous", "pressure-test", or "debate this"

Two mechanisms, in order of preference.

### Preferred: Team Debate (agent teams)

Spawn **named teammates that argue with each other directly** via `SendMessage` — a live, persistent debate where each debater keeps its own thread and engages its opponent's *latest* argument. This is the real thing, and the default when available.

> **Requires** `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` **and** that you are the **main session** — agent teams have no nested teams, so a subagent cannot spawn teammates. If either is false, use the fallback below.

In short: frame the motion → spawn 2–4 named debaters in one message (`model="opus"`, each given full context + its stance + opponents *by name*, since teammates don't inherit your history) → they open and cross-examine each other live → you **moderate** (bound the rounds, steer, detect convergence — never argue a stance yourself) → **you synthesize** what survived → shut them down.

Full protocol, spawn-prompt template, moderation rules, and variants: **`references/team-debate.md`**.

### Fallback: Round Protocol (subagents)

Use only when teams are unavailable (flag off, or you're inside a subagent). Weaker — subagents can't talk to each other, so YOU relay text between rounds against *frozen* snapshots:

1. **Round 1: Positions** — Run the standard mode (Brainstorm/Solve/Decompose). Collect agent outputs.

2. **Round 2: Challenges** — Spawn new agents in parallel, each attacking one Round 1 position. Each receives ALL Round 1 outputs and must:
   - Identify the weakest assumption in their target position
   - Present the strongest counter-argument
   - Propose a specific modification or alternative

   ```
   You are a debate challenger. Read all positions below, then attack the assigned one.

   ALL POSITIONS FROM ROUND 1:
   {all_round1_outputs}

   YOUR TARGET: Position {N} by {agent_name}
   
   1. What is the weakest assumption in this position?
   2. What evidence or logic undermines it?
   3. What do OTHER positions get right that this one misses?
   4. Propose a specific modification or superior alternative.

   Be rigorous, not hostile. The goal is truth, not winning.
   ```

3. **Round 3: Defenses** (optional, for highest stakes) — Send challenges back to original agents (or new defenders). Each must:
   - Acknowledge valid criticisms
   - Defend what survives challenge
   - Integrate insights from challengers into a revised position

4. **Final Synthesis** — YOU synthesize across all rounds. The value is in what survives challenge, not what sounded good initially.

### Constraints (both mechanisms)

- Max 3 debate rounds. Beyond that, diminishing returns.
- Each agent/teammate uses `model="opus"` for depth.
- Spawn in parallel (one message).
- Always state: "Escalating to debate because [reason]."

---

## Chaining Modes

Complex problems often need multiple modes in sequence:

| Chain | When |
|-------|------|
| Unstick → Brainstorm | Stuck on direction → once unblocked, explore options |
| Decompose → Brainstorm (per piece) | Big problem → break down → ideate on each component |
| Brainstorm → Solve | Explore options → verify the winning approach rigorously |
| Decompose → Solve (per piece) | Break down → solve each sub-problem with full rigor |
| Unstick → Decompose | Can't see the structure → reframe → then decompose clearly |

State the chain upfront: "I'll decompose first, then brainstorm on the hardest piece."

## Anti-Patterns

| Pattern | Fix |
|---------|-----|
| Using heavy-think for simple tasks | If you can answer in 30 seconds, just answer |
| Picking a mode without classifying | Always match signal → mode first |
| Skipping synthesis, just listing agent outputs | YOU must synthesize — the value is in the collision |
| Running all modes "to be thorough" | Pick the mode that fits. Chain only when necessary |
| Decomposing when you're actually stuck | Stuck ≠ complex. Stuck means you need a reframe, not more structure |
| Brainstorming when you should be solving | If there's a verifiable answer, solve. Don't ideate around it |

## References

- `references/team-debate.md` — Agent-teams debate: spawn named teammates that argue via SendMessage (preferred), with legacy fallback
- `references/team-brainstorm.md` — Agent-teams council: named teammates that build on each other's ideas via SendMessage (collaborative ideation)
- `references/brainstorm-agent-prompt.md` — Brainstorm + stress test agent prompts
- `references/perspective-combinations.md` — Pre-built perspective sets by scenario
- `references/compute.md` — Cost analysis, K selection, non-monotonic performance
- `references/tensions.md` — Design tensions: consensus vs minority, width vs depth
- `references/landscape.md` — How Solve mode compares to Best-of-N, Self-Consistency, Forest-of-Thought
- `references/paper-details.md` — HeavySkill paper methodology details
- `references/decompose-prompt.md` — Full decomposition agent prompts with variants
- `references/unstick-prompt.md` — Full unsticking agent prompts with variants
- Related skills: `problem-solving`, `sequential-thinking`