bnadlerjr/dotfiles/thinking-patterns

Thinking Patterns

Structured reasoning that produces visible, auditable output. Use when complex reasoning benefits from explicit methodology rather than relying solely on extended thinking.

Quick Start

/thinking                      # Auto-select based on context
/thinking chain-of-thought     # Explicit pattern
/thinking cot                  # Short alias

Pattern Selection Guide

What Are You Working On?

To select the right pattern, consider your task:

1. Debugging or tracing logic? → Chain of Thought
2. Researching or gathering information? → Atomic Thought
3. Comparing multiple approaches? → Tree of Thoughts
4. Creating a plan or outline? → Skeleton of Thought
5. Doing calculations or data processing? → Program of Thoughts
6. Verifying an important conclusion? → Self-Consistency
7. Synthesizing findings from multiple sources? → Graph of Thoughts

If unclear, describe your task and I'll recommend a pattern.

Auto-Selection Logic

When invoked without a specific pattern:

1. Keywords: Match trigger words to patterns
2. Task structure: Sequential → CoT, Branching → ToT, Convergent → GoT
3. Risk level: High stakes → Self-Consistency verification
4. Ask if unclear: When multiple patterns apply, ask user preference

Pattern Summaries

Chain of Thought (CoT)

Linear reasoning with explicit intermediate steps. Use for debugging, math, causal analysis.

• Output: Numbered steps building on each other
• Invoke when: "walk through", "explain", "show your work"

Atomic Thought (AoT)

Decomposes problems into independent sub-questions. Use for research and multi-hop queries.

• Output: Dependency graph → solve leaves → contract answers
• Invoke when: "understand", "research", "investigate"

Tree of Thoughts (ToT)

Explores multiple reasoning paths with evaluation. Use for design decisions and brainstorming.

• Output: 2-4 approaches with trade-offs → recommendation
• Invoke when: "what are my options", "how should I approach"

Skeleton of Thought (SoT)

Generates structure before content. Use for planning and documents.

• Output: Phase 1 skeleton → Phase 2 expansion
• Invoke when: "plan", "outline", "roadmap"

Program of Thoughts (PoT)

Delegates computation to code execution. Use for calculations requiring precision.

• Output: Natural language explanation → executable code → results
• Invoke when: "calculate", "compute", "analyze data"

Self-Consistency

Samples multiple reasoning paths and aggregates. Use for verification.

• Output: 3-5 independent paths → consensus check → confidence assessment
• Invoke when: "double-check", "verify", "make sure"

Graph of Thoughts (GoT)

Models reasoning as graph with aggregation and refinement. Use for synthesis.

• Output: Extract insights → identify conflicts → resolve → unified synthesis
• Invoke when: "combine", "synthesize", "integrate"

Workflow Integration

Composition Patterns

Patterns can be composed for complex tasks:

Detailed Pattern Reference

For full pattern definitions including:

• Core mechanisms and processes
• Activation methods
• Examples and templates
• Anti-patterns to avoid

See patterns.md.

Success Criteria

A thinking pattern is successfully applied when:

• [ ] Appropriate pattern selected for the task type
• [ ] Visible structured output produced (not just internal reasoning)
• [ ] Each step/node explicitly shown and verifiable
• [ ] Final answer traces back to the reasoning
• [ ] User can audit and validate the reasoning process