Tree of Thoughts Reasoning Methodology

Purpose: Systematic parallel exploration of solution spaces through recursive branching, self-reflection, and rigorous evaluation. Use this methodology when facing complex problems with multiple viable solution paths.

When to Use Tree of Thoughts

✅ Use ToT when:

• •Problem has multiple viable solution approaches (3+ fundamentally different paths)
• •Need to find optimal solution, not just any solution
• •Can define clear evaluation criteria
• •Complexity justifies systematic exploration
• •Trade-offs exist between competing approaches
• •Strategic or architectural decisions with long-term impact

❌ Don't use ToT when:

• •Problem has obvious single solution path
• •Time-critical decisions with simple trade-offs
• •Problem is well-defined with standard solution
• •Exploratory work where breadth matters more than depth

Examples:

• •"Should we use REST, GraphQL, or gRPC?" (3 paths, clear trade-offs) ✅
• •"Design distributed caching system balancing latency, consistency, cost" (multi-dimensional) ✅
• •"Fix this syntax error" (single path) ❌
• •"Research all available databases" (breadth-of-thought better) ❌

Core Methodology: 5-Step Process

Step 1: Problem Decomposition (5+ Branches)

Objective: Identify 5+ fundamentally different approaches to explore

Actions:

1. •Analyze problem to identify key dimensions (technical, organizational, risk, cost, timeline)
2. •Brainstorm 5-10 distinct approaches (not variations of same approach)
3. •Define evaluation criteria from problem constraints
4. •Validate diversity: Each branch explores different solution philosophy

Example (Distributed Caching):

Branch A: Write-through consistency (strong consistency, higher latency)
Branch B: Eventual consistency (performance, weaker guarantees)
Branch C: Hybrid tiered (hot data write-through, cold data eventual)
Branch D: Edge-centric (CDN-style, geography-aware)
Branch E: Cost-optimized minimal (single region, no replication)

Deliverable: 5+ distinct approach definitions

Step 2: Parallel Branch Exploration

Objective: Explore each branch systematically with self-reflection

For each branch:

1. •Analyze approach against problem requirements
2. •Consider strengths, weaknesses, trade-offs
3. •Identify assumptions and constraints
4. •End with self-reflection (see template below)

Self-Reflection Template (REQUIRED for each branch):

## Branch [X]: [Approach Name]

[Analysis of this approach: 2-4 paragraphs covering requirements, strengths, weaknesses, trade-offs]

### Self-Reflection
- **Confidence**: [0-100]/100
- **Strengths**: [What makes this approach compelling]
- **Weaknesses**: [Gaps, assumptions, limitations]
- **Trade-offs**: [What you gain vs what you lose]
- **Recommendation**: [Continue deeper exploration? Prune? Why?]

Execution Options:

• •With Task tool: Spawn 5+ parallel tasks for independent exploration
• •Without Task tool: Explore branches sequentially using TodoWrite to track progress
• •Hybrid: Use Task for complex branches, sequential for simple ones

Deliverable: 5+ explored branches with self-reflections

Step 3: Branch Evaluation (Scoring)

Objective: Systematically evaluate all branches against criteria

Evaluation Criteria (100 points total, 5 categories × 20 points):

1. •

   Novelty (0-20): Does it explore new solution space vs obvious approaches?

   • •18-20: Innovative approach, fresh perspective
   • •12-17: Good approach with some novel elements
   • •6-11: Standard approach, minor tweaks
   • •0-5: Obvious/conventional approach
2. •

   Feasibility (0-20): Practically implementable with reasonable resources?

   • •18-20: Proven technology, clear implementation path
   • •12-17: Feasible with moderate effort/risk
   • •6-11: Significant technical challenges
   • •0-5: Impractical or resource-intensive
3. •

   Completeness (0-20): Addresses all stated requirements?

   • •18-20: Covers all requirements comprehensively
   • •12-17: Covers most requirements, minor gaps
   • •6-11: Missing key requirements
   • •0-5: Incomplete solution
4. •

   Confidence (0-20): Branch's self-reflection confidence score?

   • •18-20: High confidence (80-100%) with justification
   • •12-17: Medium confidence (60-79%)
   • •6-11: Low confidence (40-59%)
   • •0-5: Very low confidence (<40%)
5. •

   Alignment (0-20): Matches problem constraints and context?

   • •18-20: Perfect fit for constraints
   • •12-17: Good fit, minor misalignment
   • •6-11: Notable misalignment
   • •0-5: Poor fit for context

Scoring Process:

1. •Review each branch's analysis and self-reflection
2. •Score each branch on all 5 criteria (0-20 per criterion)
3. •Calculate total score (0-100) for each branch
4. •Rank branches by total score
5. •Select highest-scoring branch for deeper exploration

Deliverable: Scored ranking of all branches, winner selected

Step 4: Recursive Depth Exploration (Level 1+)

Objective: Recursively expand the best branch

Actions:

1. •Take highest-scoring branch from Step 3
2. •Decompose that branch into 5+ sub-approaches or refinements
3. •Repeat Steps 2-3 for the new level (explore → evaluate → select)
4. •Continue recursion until stopping criteria met

Minimum Depth: 4 levels (Level 0 → 1 → 2 → 3)

Level Transition Example:

Level 0: "Distributed caching system" (5 approaches)
  → Winner: Branch B (Eventual consistency)

Level 1: "Eventual consistency variants" (5 refinements)
  - B.1: Last-write-wins
  - B.2: Version vectors
  - B.3: CRDTs
  - B.4: Causal consistency
  - B.5: Session consistency
  → Winner: Branch B.3 (CRDTs)

Level 2: "CRDT implementations" (5 options)
  - B.3.1: G-Counter
  - B.3.2: PN-Counter
  - B.3.3: LWW-Element-Set
  - B.3.4: OR-Set
  - B.3.5: RGA (Replicated Growable Array)
  → Winner: Branch B.3.4 (OR-Set)

Level 3: "OR-Set optimizations" (5 variants)
  [Explore specific implementation strategies]
  → Winner: Branch B.3.4.2 (Tombstone compaction)

Deliverable: Recursive tree with minimum 4 levels explored

Step 5: Final Synthesis

Objective: Synthesize insights into final recommendation

Actions:

1. •Trace winning path: Document Level 0 → Level 1 → Level 2 → Level 3+
2. •Extract key insights: What was learned at each level?
3. •Document pruned branches: Why were alternatives discarded?
4. •Calculate confidence: Final confidence score (see Bayesian formula below)
5. •State assumptions: What assumptions underpin the recommendation?
6. •Provide recommendation: Clear, actionable guidance

Synthesis Template:

## Tree of Thoughts Analysis Complete

### Winning Path
- **Level 0**: [Chosen approach] (Score: X/100)
- **Level 1**: [Refinement] (Score: X/100)
- **Level 2**: [Sub-refinement] (Score: X/100)
- **Level 3**: [Implementation] (Score: X/100)

### Key Insights
1. [Insight from Level 0]
2. [Insight from Level 1]
3. [Insight from Level 2]
4. [Insight from Level 3]

### Alternatives Considered
- [Branch A]: Pruned because [reason]
- [Branch C]: Pruned because [reason]
- [Branch D]: Pruned because [reason]

### Final Confidence: [X]%

**Justification**: [Why this confidence level based on exploration depth, evidence, and remaining uncertainties]

### Recommendation
[Clear, actionable recommendation with next steps]

### Remaining Uncertainties
- [Assumption 1]
- [Assumption 2]

Deliverable: Comprehensive synthesis with traced path and confidence score

Stopping Criteria

Stop exploration when ANY of:

1. •✅ Reached 4+ levels AND best branch confidence >80%
2. •✅ Reached 6 levels (maximum recommended depth)
3. •✅ All branches converge to same solution across multiple levels
4. •✅ Diminishing returns (Level N scores similar to Level N-1)

Warning signs (don't stop yet):

• •❌ Only 2-3 levels explored
• •❌ Confidence <80% without clear reason
• •❌ Winner not clearly superior to alternatives

Bayesian Confidence Scoring

Purpose: Quantify confidence based on accumulated evidence

Formula:

Prior Odds = P(correct) / (1 - P(correct))
Likelihood Ratio = Evidence strength (from scores)
Posterior Odds = Prior Odds × Likelihood Ratio
Final Confidence = Posterior Odds / (1 + Posterior Odds)

Practical Calculation:

1. •Start with prior confidence: 50% (neutral)
2. •For each evaluation criterion score (0-20):
   • •Convert to likelihood ratio: LR = 0.25 + (score/20) * 3.75
   • •Update odds: Odds = Odds × LR
3. •Convert back to probability: Conf = Odds / (1 + Odds)
4. •Cap at 95% (Bayesian humility for unknown unknowns)

Example:

• •Branch scores: Novelty 18/20, Feasibility 19/20, Completeness 17/20, Confidence 18/20, Alignment 19/20
• •Likelihood ratios: 3.62, 3.81, 3.44, 3.62, 3.81
• •Final odds: 1.0 × 3.62 × 3.81 × 3.44 × 3.62 × 3.81 = 1,782
• •Confidence: 1782 / 1783 = 99.9% → Capped at 95%

Confidence Interpretation:

• •90-95%: Exceptional evidence, suitable for critical decisions
• •80-89%: High confidence, suitable for important decisions
• •70-79%: Medium confidence, consider additional validation
• •60-69%: Low confidence, recommend further investigation
• •<60%: Very low confidence, gather more information

Self-Critique Checklist

After applying ToT methodology, verify:

• • Branch Diversity: Are all 5+ branches fundamentally different (not variations)?
• • Self-Reflection Quality: Does each branch have genuine self-reflection (not boilerplate)?
• • Evaluation Rigor: Did I systematically score all 5 criteria for each branch?
• • Depth Achievement: Did I reach minimum 4 levels of exploration?
• • Confidence Validity: Is final confidence score justified by exploration depth?
• • Pruning Rationale: Can I explain why each non-selected branch was discarded?
• • Path Traceability: Can I clearly trace the winning path from root to leaf?
• • Synthesis Clarity: Does final output provide actionable recommendation?
• • Stopping Appropriateness: Did I stop for valid reasons per criteria?

Common Mistakes to Avoid

1. •Too Few Branches: Using <5 branches reduces exploration quality
2. •Variation vs Diversity: Creating 5 variations of same approach instead of 5 different approaches
3. •Shallow Depth: Stopping at 1-2 levels instead of minimum 4
4. •Biased Evaluation: Favoring familiar approaches without systematic scoring
5. •Missing Self-Reflection: Skipping confidence assessment in branches
6. •Premature Convergence: Selecting winner before thorough evaluation
7. •Over-Recursion: Going beyond 6 levels without clear benefit
8. •Poor Synthesis: Not clearly documenting winning path and rationale

Reference Documentation

Detailed Templates: ~/.claude/skills/tree-of-thoughts/references/tree-of-thoughts-patterns.md

Includes:

• •Branch exploration template (detailed prompts)
• •Self-reflection rubric (confidence scoring guide)
• •Evaluation matrix (scoring examples per criterion)
• •Level transition logic (when/how to deepen)
• •Edge case handling (convergence, insufficient diversity)

Quick Start Examples

Example 1: Simple Decision (3 levels)

Problem: Choose between Redis, Memcached, or Hazelcast for caching

Level 0 (3 branches):

• •Branch A: Redis (rich data structures)
• •Branch B: Memcached (pure speed)
• •Branch C: Hazelcast (distributed computing) → Winner: Branch A (Redis) - 85/100

Level 1 (Redis deployment options):

• •A.1: Single instance
• •A.2: Sentinel (high availability)
• •A.3: Cluster (horizontal scaling)
• •A.4: Redis Enterprise
• •A.5: Managed service (AWS ElastiCache) → Winner: Branch A.3 (Cluster) - 88/100

Level 2 (Cluster configuration):

• •A.3.1: 3 masters, no replicas
• •A.3.2: 3 masters, 3 replicas
• •A.3.3: 6 masters, 6 replicas
• •A.3.4: Auto-scaling cluster
• •A.3.5: Hybrid (critical data replicated) → Winner: Branch A.3.2 (3+3) - 91/100

Confidence: 88% (3 levels, clear winner at each level)

Example 2: Complex Architecture (5 levels)

Problem: Design microservices communication strategy

Level 0: REST, gRPC, Message Queue, Event Sourcing, GraphQL (5 approaches) Level 1: [Winner] expanded into 5 sub-approaches Level 2: [Winner] expanded into 5 implementation variants Level 3: [Winner] expanded into 5 technology choices Level 4: [Winner] expanded into 5 deployment patterns

Confidence: 93% (5 levels, 25+ branches explored total)

Summary

Tree of Thoughts is a systematic methodology for exploring complex problem spaces through:

1. •Parallel branching (5+ approaches per level)
2. •Self-reflection (confidence scoring for each branch)
3. •Rigorous evaluation (5 criteria, 0-100 scoring)
4. •Recursive depth (minimum 4 levels)
5. •Bayesian confidence (evidence-based scoring)

Use it for strategic decisions, architectural choices, and optimization problems where systematic exploration yields better outcomes than intuition alone.

Remember: Quality over speed. ToT trades time for rigor. The goal is high-confidence optimal solutions, not quick answers.