@rfxlamia/skillkit 1.1.0 → 1.2.0

package/skills/skills/prompt-engineering/references/self-consistency.md

@@ -0,0 +1,322 @@
+# Self-Consistency Prompting
+
+## Overview
+
+Self-Consistency generates multiple reasoning paths independently, then selects the most consistent answer. Improves accuracy for high-stakes decisions by comparing multiple solutions.
+
+## When to Use
+
+✅ **Use Self-Consistency When:**
+- High-stakes decisions requiring verification
+- Accuracy is more important than speed
+- Multiple reasoning paths are possible
+- Need confidence in the answer
+- Problem has objective correct answer
+- Cost of error is high
+
+❌ **Don't Use Self-Consistency When:**
+- Simple tasks with obvious answers
+- Speed is critical (Self-Consistency is slow)
+- Token budget is tight (very expensive)
+- Subjective questions (no "correct" answer)
+- Creative tasks (variety is good, not consensus)
+
+## Method
+
+1. **Generate** 3-10 independent reasoning paths
+2. **Compare** final answers from all paths
+3. **Select** most consistent/common answer
+4. **Verify** by investigating discrepancies
+
+## Structure
+
+```
+Problem → 
+  Path 1 (Method A) → Answer 1
+  Path 2 (Method B) → Answer 2  
+  Path 3 (Method C) → Answer 3
+  Path 4 (Method D) → Answer 4
+  Path 5 (Method E) → Answer 5
+→ Consistency Check → Final Answer
+```
+
+## Template
+
+```
+Problem: [Critical problem requiring high confidence]
+
+I will solve this using 5 different reasoning approaches to ensure consistency.
+
+Approach 1 (Method: [e.g., Direct calculation]):
+[Reasoning steps]
+Answer 1: [Result]
+
+Approach 2 (Method: [e.g., Work backwards]):
+[Reasoning steps]
+Answer 2: [Result]
+
+Approach 3 (Method: [e.g., Analogical reasoning]):
+[Reasoning steps]
+Answer 3: [Result]
+
+Approach 4 (Method: [e.g., Formula-based]):
+[Reasoning steps]
+Answer 4: [Result]
+
+Approach 5 (Method: [e.g., Verification approach]):
+[Reasoning steps]
+Answer 5: [Result]
+
+Consistency Check:
+- All answers: [List: Answer 1, Answer 2, Answer 3, Answer 4, Answer 5]
+- Most common answer: [X appears Y times]
+- Confidence: [High/Medium/Low based on agreement]
+- Discrepancies: [Note any different answers]
+- Investigation: [If answers differ, why?]
+
+Final Answer: [Most consistent answer with reasoning]
+Confidence: [Percentage based on agreement]
+```
+
+## Best Practices
+
+✓ Use 5-7 diverse reasoning paths (optimal)
+✓ Vary approaches/starting points genuinely
+✓ Compare answers, don't just pick majority
+✓ Investigate disagreements seriously
+✓ Use different methods, not just repeat same logic
+
+✗ Don't use identical reasoning each time
+✗ Avoid stopping at first answer
+✗ Don't ignore minority answers without investigation
+✗ Don't use self-consistency for subjective questions
+
+## Example: Mathematical Problem
+
+```
+Problem: A store sells apples at $2 for 3 apples. 
+If you buy 17 apples, how much do you pay?
+
+Approach 1 (Bundle counting):
+Step 1: 17 apples ÷ 3 = 5 bundles + 2 individual
+Step 2: 5 bundles × $2 = $10
+Step 3: 2 individual × ($2÷3) = $1.33
+Answer 1: $11.33
+
+Approach 2 (Unit price):
+Step 1: Price per apple = $2 ÷ 3 = $0.667
+Step 2: 17 apples × $0.667 = $11.33
+Answer 2: $11.33
+
+Approach 3 (Work backwards from total):
+Step 1: For $11, I get 16.5 apples (11 ÷ 2 × 3)
+Step 2: Need 0.5 more apple = $0.33
+Answer 3: $11.33
+
+Approach 4 (Proportion):
+Step 1: 3 apples : $2 = 17 apples : X
+Step 2: X = (17 × $2) ÷ 3 = $11.33
+Answer 4: $11.33
+
+Approach 5 (Verification):
+Step 1: At $11.33, I should get 17 apples
+Step 2: $11.33 ÷ $2 = 5.665 bundles
+Step 3: 5.665 × 3 = 17 apples ✓
+Answer 5: $11.33
+
+Consistency Check:
+- All 5 approaches agree: $11.33
+- Confidence: Very High (100% agreement)
+- No discrepancies to investigate
+
+Final Answer: $11.33 (Verified through 5 independent methods)
+```
+
+## Example: Decision-Making
+
+```
+Problem: Should we migrate our database from PostgreSQL to MongoDB?
+
+Approach 1 (Performance analysis):
+- Current query patterns: 80% relational, 20% document
+- Relational queries would become slower in MongoDB
+- Document queries marginally faster
+Conclusion 1: Stay with PostgreSQL
+
+Approach 2 (Cost analysis):
+- Migration cost: $50K (engineering time)
+- MongoDB licenses: +$10K/year
+- PostgreSQL optimizations: $15K (one-time)
+- 3-year TCO: MongoDB $80K, PostgreSQL $15K
+Conclusion 2: Stay with PostgreSQL
+
+Approach 3 (Team expertise):
+- Team has 5 years PostgreSQL experience
+- MongoDB: No experience, 6-month learning curve
+- Risk of migration bugs: High
+Conclusion 3: Stay with PostgreSQL
+
+Approach 4 (Scalability needs):
+- Current scale: 1TB, 10K QPS
+- PostgreSQL scales to 10TB, 100K QPS (sufficient)
+- MongoDB advantages not needed at our scale
+Conclusion 4: Stay with PostgreSQL
+
+Approach 5 (Industry trends):
+- Competitors use both successfully
+- No compelling reason to switch
+- "If it ain't broke, don't fix it"
+Conclusion 5: Stay with PostgreSQL
+
+Consistency Check:
+- All 5 analyses agree: Stay with PostgreSQL
+- Confidence: Very High (unanimous)
+- Key factors: Cost, expertise, current performance adequate
+
+Final Decision: Stay with PostgreSQL
+Confidence: 95%
+Rationale: All analysis approaches converge on same conclusion
+```
+
+## Diversity of Approaches
+
+### Good Diversity (Different Methods):
+```
+1. Mathematical formula
+2. Analogical reasoning  
+3. Work backwards
+4. Case-by-case analysis
+5. Verification approach
+```
+
+### Bad Diversity (Same Method):
+```
+1. Formula approach
+2. Formula approach (slightly different notation)
+3. Formula approach (in different order)
+4. Formula approach (with verification)
+5. Formula approach (repeated)
+```
+
+**Key:** Use genuinely different reasoning strategies.
+
+## Handling Disagreements
+
+### If 3/5 Agree:
+```
+Majority: Answer A (3 times)
+Minority: Answer B (2 times)
+
+Action:
+1. Review minority reasoning carefully
+2. Check for calculation errors in majority
+3. Consider if minority found edge case
+4. Re-calculate using hybrid approach
+5. Report: "Answer A with medium confidence (60%)"
+```
+
+### If No Consensus (2-2-1 split):
+```
+Answer A: 2 times
+Answer B: 2 times  
+Answer C: 1 time
+
+Action:
+1. Add 2-3 more approaches to break tie
+2. Deep-dive into why disagreement exists
+3. Check assumptions in each approach
+4. Report: "Low confidence, needs more analysis"
+```
+
+## Confidence Scoring
+
+| Agreement | Confidence | Action |
+|-----------|-----------|--------|
+| 5/5 or 4/5 | Very High (90%+) | Accept answer |
+| 3/5 | Medium (60-70%) | Investigate minority views |
+| 2/5 or worse | Low (<50%) | Add more approaches or flag for review |
+
+## Token Cost
+
+Self-Consistency is very expensive:
+
+**Typical costs:**
+- 5 approaches × 100 tokens each = 500 tokens
+- Consistency check: 100 tokens
+- **Total: 500-3000+ tokens**
+
+**When to justify the cost:**
+- Critical business decisions
+- Safety-critical calculations
+- Legal/compliance requirements
+- High-value transactions
+- Medical diagnoses support
+
+## Optimization Strategies
+
+### Reduce Paths:
+```
+Instead of 7 paths → Use 5 paths
+Savings: ~200 tokens
+Trade-off: Slightly less confidence
+```
+
+### Compact Format:
+```
+Don't write: "In the first approach, using the method of..."
+Write: "Approach 1 (Direct): Answer = X"
+```
+
+### Early Termination:
+```
+If first 3 approaches all agree:
+  → Can stop early with high confidence
+  → Save tokens on approaches 4-5
+```
+
+## Self-Consistency vs Other Methods
+
+| Method | Paths | Speed | Cost | Best For |
+|--------|-------|-------|------|----------|
+| Zero-Shot | 1 | Fast | Low | Simple tasks |
+| CoT | 1 | Medium | Medium | Reasoning |
+| ToT | Multiple (explored) | Slow | High | Planning |
+| Self-Consistency | Multiple (independent) | Slow | High | Verification |
+
+**Key difference:** 
+- **ToT** explores paths in a tree (dependent)
+- **Self-Consistency** generates independent parallel paths
+
+## Real-World Use Cases
+
+### ✅ Good Use Cases:
+- Financial calculations for large transactions
+- Medical diagnosis support (with human oversight)
+- Legal contract analysis
+- Engineering safety calculations
+- Risk assessment for critical decisions
+
+### ❌ Bad Use Cases:
+- "What's the capital of France?" (obvious answer)
+- Creative writing (variety is good)
+- Subjective preferences
+- Time-sensitive queries
+- Low-stakes decisions
+
+## Quick Reference
+
+| Aspect | Recommendation |
+|--------|---------------|
+| **Number of paths** | 5-7 approaches |
+| **Diversity** | Use genuinely different methods |
+| **Agreement threshold** | 60%+ for medium confidence |
+| **Token cost** | 500-3000+ tokens |
+| **Best for** | High-stakes, objective problems |
+| **Confidence metric** | % of approaches agreeing |
+
+---
+
+**Related:**
+- [Chain of Thought](chain-of-thought.md) - Single reasoning path
+- [Tree of Thoughts](tree-of-thoughts.md) - Explored paths (not independent)
+- [Decision Matrix](decision_matrix.md) - When to use Self-Consistency

package/skills/skills/prompt-engineering/references/tree-of-thoughts.md

@@ -0,0 +1,386 @@
+# Tree of Thoughts (ToT) Prompting
+
+## Overview
+
+Tree of Thoughts explores multiple reasoning paths in a tree structure, evaluating alternatives before selecting the best solution. Useful for complex planning and problems requiring exploration.
+
+## When to Use
+
+✅ **Use ToT When:**
+- Complex planning requiring exploration of alternatives
+- Multiple solution paths need evaluation
+- Strategic games, puzzles, or optimization problems
+- Creative tasks benefiting from exploring options
+- Need to backtrack if a path fails
+- Problem has no single obvious solution
+
+❌ **Don't Use ToT When:**
+- Simple, straightforward tasks
+- Single clear solution path
+- Token budget is tight (ToT is expensive)
+- Time is critical (ToT is slower)
+- Problem is well-defined with known approach
+
+## Structure
+
+```
+Initial State 
+  → Generate Multiple Thoughts (Level 1)
+  → Evaluate Each Thought
+  → Select Best Thought(s)
+  → Generate Sub-Thoughts (Level 2)
+  → Evaluate
+  → Select Best
+  → ... Continue
+  → Final Solution
+```
+
+## Best Practices
+
+✓ Generate 3-5 alternative thoughts per node
+✓ Define clear evaluation criteria upfront
+✓ Allow backtracking to previous states
+✓ Prune obviously bad paths early
+✓ Set depth limit (typically 3-4 levels)
+
+✗ Don't explore infinitely (set limits)
+✗ Avoid bias toward first generated option
+✗ Don't use identical evaluation for all options
+✗ Don't forget to compare alternatives
+
+## Template: Natural Language
+
+```
+Problem: [Complex problem requiring exploration]
+
+Approach: I will explore multiple solution paths using Tree of Thoughts
+
+Initial State: [Starting condition]
+
+Level 1 - Generate Possible Approaches:
+Option A: [First approach]
+Option B: [Second approach]
+Option C: [Third approach]
+
+Evaluate Level 1:
+- Option A: [Score/reasoning]
+  Pros: [advantages]
+  Cons: [disadvantages]
+  
+- Option B: [Score/reasoning]
+  Pros: [advantages]
+  Cons: [disadvantages]
+  
+- Option C: [Score/reasoning]
+  Pros: [advantages]
+  Cons: [disadvantages]
+
+Select Best: [Option X] because [reasoning]
+
+Level 2 - Expand Option X:
+Path X.1: [Sub-approach 1]
+Path X.2: [Sub-approach 2]
+Path X.3: [Sub-approach 3]
+
+Evaluate Level 2:
+[Score each path...]
+
+Final Solution: [Best path found through tree]
+```
+
+## Template: YAML Format (Human-Readable)
+
+```yaml
+problem: "[Problem statement]"
+
+tree_of_thoughts:
+  root:
+    state: "[Initial state]"
+    
+  level_1:
+    thoughts:
+      - id: "A"
+        description: "[First approach]"
+        evaluation:
+          score: 0.8
+          reasoning: "[Why this might work]"
+          pros: ["Pro 1", "Pro 2"]
+          cons: ["Con 1"]
+          
+      - id: "B"
+        description: "[Second approach]"
+        evaluation:
+          score: 0.6
+          reasoning: "[Why this might work]"
+          pros: ["Pro 1"]
+          cons: ["Con 1", "Con 2"]
+          
+      - id: "C"
+        description: "[Third approach]"
+        evaluation:
+          score: 0.9
+          reasoning: "[Why this might work]"
+          pros: ["Pro 1", "Pro 2", "Pro 3"]
+          cons: []
+          
+    selected: "C"
+    reason: "[Why C is best]"
+    
+  level_2:
+    parent: "C"
+    thoughts:
+      - id: "C.1"
+        description: "[Refined approach]"
+        evaluation:
+          score: 0.85
+          
+      - id: "C.2"
+        description: "[Alternative refinement]"
+        evaluation:
+          score: 0.95
+          
+    selected: "C.2"
+    
+solution:
+  path: ["C", "C.2"]
+  final_answer: "[Detailed solution]"
+  rationale: "[Why this path is optimal]"
+```
+
+## Template: XML Format (Claude-Optimized)
+
+```xml
+<tree_of_thoughts>
+  <problem>[Complex planning problem]</problem>
+  
+  <exploration_config>
+    <max_depth>3</max_depth>
+    <branches_per_level>3</branches_per_level>
+    <evaluation_criteria>
+      <criterion weight="0.4">Feasibility</criterion>
+      <criterion weight="0.3">Cost</criterion>
+      <criterion weight="0.3">Time</criterion>
+    </evaluation_criteria>
+  </exploration_config>
+  
+  <level_1>
+    <thought id="A">
+      <description>[Approach A]</description>
+      <evaluation>
+        <feasibility>0.9</feasibility>
+        <cost>0.6</cost>
+        <time>0.7</time>
+        <total_score>0.75</total_score>
+      </evaluation>
+    </thought>
+    
+    <thought id="B">
+      <description>[Approach B]</description>
+      <evaluation>
+        <feasibility>0.7</feasibility>
+        <cost>0.8</cost>
+        <time>0.6</time>
+        <total_score>0.70</total_score>
+      </evaluation>
+    </thought>
+    
+    <selected>A</selected>
+    <reason>[Why A is selected]</reason>
+  </level_1>
+  
+  <level_2>
+    <parent>A</parent>
+    <!-- Continue expansion -->
+  </level_2>
+  
+  <final_solution>
+    <path>A → A.2 → A.2.1</path>
+    <answer>[Solution details]</answer>
+  </final_solution>
+</tree_of_thoughts>
+```
+
+## Real-World Example: Trip Planning
+
+```
+Problem: Plan a 7-day trip to Japan with $3000 budget, 
+focusing on cultural sites and food experiences.
+
+Tree of Thoughts Approach:
+
+Level 1 - City Combinations:
+Option A: Tokyo only (7 days)
+  Score: 7/10
+  Pros: Deep dive, no travel time between cities
+  Cons: Less variety, misses Kyoto temples
+  Budget: Under budget (~$2500)
+  
+Option B: Tokyo (4 days) + Kyoto (3 days)
+  Score: 9/10
+  Pros: Great culture balance, iconic sites
+  Cons: 1 travel day lost
+  Budget: Fits budget (~$2900)
+  
+Option C: Tokyo (3) + Osaka (2) + Kyoto (2)
+  Score: 6/10
+  Pros: Maximum variety
+  Cons: Too rushed, over budget, constant packing
+  Budget: Over budget (~$3200)
+  
+Selected: Option B (Tokyo 4 + Kyoto 3)
+
+Level 2 - Tokyo Allocation (4 days):
+B.1: Shibuya/Shinjuku (1) + Asakusa/temples (1) + 
+     Tokyo Disney (1) + Akihabara (1)
+  Score: 7/10
+  
+B.2: Shibuya/Shinjuku (1) + Asakusa (1) + 
+     Tsukiji/food tour (1) + Museums (1)
+  Score: 9/10
+  Aligns better with "cultural + food" focus
+  
+B.3: Mix modern + traditional split evenly
+  Score: 8/10
+  
+Selected: B.2
+
+Level 3 - Kyoto Allocation (3 days):
+B.2.1: Temples (2 days) + Arashiyama (1 day)
+B.2.2: Temples (1.5) + Gion (1) + Food tour (0.5)
+  Score: 9/10 - Better balance
+  
+Final Solution:
+Path: B → B.2 → B.2.2
+Days 1-4: Tokyo (Shibuya, Asakusa, Tsukiji food, Museums)
+Days 5-7: Kyoto (Temples 1.5 days, Gion district, Food tour)
+Budget: $2,850 (within limit)
+```
+
+## Evaluation Criteria Examples
+
+### For Planning Tasks:
+- **Feasibility:** Can it actually be done?
+- **Cost:** Financial constraints
+- **Time:** Time requirements
+- **Risk:** What could go wrong?
+- **Impact:** Expected benefit
+
+### For Technical Solutions:
+- **Performance:** Speed/efficiency
+- **Maintainability:** Long-term code quality
+- **Scalability:** Growth potential
+- **Security:** Vulnerability assessment
+- **Complexity:** Implementation difficulty
+
+### For Creative Tasks:
+- **Originality:** Uniqueness of idea
+- **Coherence:** Internal consistency
+- **Engagement:** Audience appeal
+- **Feasibility:** Can it be executed?
+- **Impact:** Desired effect achieved
+
+## Pruning Strategies
+
+### Early Pruning:
+```
+If thought scores < 0.3 on any critical criterion:
+  → Prune immediately, don't explore further
+  
+If multiple thoughts score > 0.8:
+  → Explore top 2-3 only (save tokens)
+```
+
+### Mid-Pruning:
+```
+After Level 2:
+  → Review paths from root to current leaves
+  → Prune paths with cumulative score < threshold
+  → Focus resources on promising branches
+```
+
+## Backtracking Example
+
+```
+Level 1: Selected Option A (score 0.9)
+
+Level 2: Expanded A
+  A.1: Score 0.6
+  A.2: Score 0.5
+  A.3: Score 0.4
+  
+All sub-options score poorly!
+
+BACKTRACK to Level 1
+Select Option B (second-best, score 0.8)
+
+Level 2: Expanded B
+  B.1: Score 0.9 ✓
+  B.2: Score 0.85 ✓
+  
+Continue with B.1 path
+```
+
+## Comparing ToT to Other Methods
+
+| Aspect | Zero-Shot | Few-Shot | CoT | ToT |
+|--------|-----------|----------|-----|-----|
+| **Paths explored** | 1 | 1 | 1 | Multiple |
+| **Backtracking** | No | No | No | Yes |
+| **Evaluation** | No | Implicit | No | Explicit |
+| **Token cost** | Low | Medium | Medium | High |
+| **Best for** | Simple | Format | Reasoning | Planning |
+
+## Token Cost
+
+ToT is expensive due to exploring multiple paths:
+
+**Typical costs:**
+- Level 1 (3 options): ~200 tokens
+- Level 2 (3 options per branch): ~400 tokens
+- Level 3: ~600 tokens
+- Evaluation overhead: ~300 tokens
+- **Total: 500-2000+ tokens**
+
+**Optimization:**
+- Limit breadth (3 options per level, not 5)
+- Limit depth (2-3 levels, not 5)
+- Prune early and aggressively
+- Use compact format (not verbose)
+
+## When ToT is Overkill
+
+❌ **Don't use ToT for:**
+```
+- "What is 2+2?" (use Zero-Shot)
+- "Translate this to Spanish" (use Zero-Shot)
+- "Extract email from text" (use Few-Shot)
+- "Explain recursion" (use CoT)
+```
+
+✅ **Use ToT for:**
+```
+- "Design a scalable architecture for..."
+- "Plan a marketing campaign with..."
+- "Optimize supply chain considering..."
+- "Choose technology stack for..."
+```
+
+## Quick Reference
+
+| Aspect | Recommendation |
+|--------|---------------|
+| **Levels** | 2-3 (rarely >4) |
+| **Branches per level** | 3-5 options |
+| **Evaluation criteria** | 3-5 weighted factors |
+| **Pruning** | Aggressive (score <0.4) |
+| **Format** | YAML (readable) or XML (Claude) |
+| **Token cost** | 500-2000+ tokens |
+| **Best for** | Planning, strategy, optimization |
+
+---
+
+**Related:**
+- [Chain of Thought](chain-of-thought.md) - Single path reasoning
+- [Self-Consistency](self-consistency.md) - Multiple paths, same method
+- [YAML Format](yaml-format.md) - Human-readable format for ToT
+- [Decision Matrix](decision_matrix.md) - When to use ToT