problem-solving

What this skill does

# Problem-Solving Frameworks

Systematic techniques for breaking through complex problems, finding simplifying insights, and matching the right approach to your specific type of stuck.

## When to Use

Each framework targets a different type of "stuck":

| Symptom | Use This |
|---------|----------|
| Same thing implemented 5+ ways, complexity spiraling | **Simplification Cascades** |
| Can't find fitting approach, need breakthrough | **Collision Zone Thinking** |
| Same pattern in 3+ domains, reinventing wheels | **Meta-Pattern Recognition** |
| Will this scale? Edge cases unclear | **Scale Game** |
| Solution feels forced, "must be done this way" | **Inversion Exercise** |
| Unsure which technique to use | **When Stuck Dispatch** |

## Quick Reference

### 🎯 **@references/when-stuck.md** - Technique Dispatch
Decision tree to quickly identify which problem-solving technique to use based on your specific stuck-symptom.

### 🎨 **@references/collision-zones.md** - Force Unrelated Concepts Together
"What if we treated X like Y?" - Deliberate metaphor-mixing for breakthrough innovation.

**Examples:**
- Treat code like DNA → Mutation testing, evolutionary algorithms
- Treat architecture like Lego → Composable microservices
- Treat data like water → Streaming, data lakes
- Treat requests like postal mail → Message queues, async processing

### 🔄 **@references/simplification.md** - Find Unifying Insights
"If this is true, we don't need X, Y, or Z" - One insight that eliminates multiple components.

**Look for:**
- Same thing implemented 5+ ways
- Growing special case list
- Excessive if/else branching
- Multiple config variations

### 🔍 **@references/meta-patterns.md** - Spot Universal Principles
When the same pattern appears in 3+ domains, extract the universal principle.

**Examples:**
- Caching (CPU, DB, HTTP, DNS, LLM prompts, CDN)
- Layering (network stack, storage, architecture)
- Queuing (message, task, request queues)
- Pooling (connections, threads, objects, resources)

### ⚖️ **@references/scale-game.md** - Test at Extremes
1000x bigger/smaller, instant/year-long - extremes expose fundamental truths.

**Test dimensions:**
- Volume: 1 item vs 1 billion items
- Speed: Instant vs 1 year
- Users: 1 vs 1 billion concurrent
- Duration: Milliseconds vs years
- Failure rate: Never vs always fails

### 🔀 **@references/inversion.md** - Flip Assumptions
"What if the opposite were true?" - Reveals hidden constraints and alternatives.

**Examples:**
- Cache to reduce latency → Add latency to enable caching (debouncing)
- Pull data when needed → Push data before needed (prefetching)
- Handle errors when occur → Make errors impossible (type systems)
- Build features wanted → Remove features not needed (simplicity)

## Common Patterns

### Stuck on Complexity

```
1. List all similar implementations
2. Extract common pattern
3. Create general case
4. Replace all with unified implementation
5. Result: 5 components → 1 component
```

See @references/simplification.md

### Need Innovation

```
1. Pick two unrelated concepts (different domains)
2. Force combination: "What if [A] like [B]?"
3. Explore emergent properties
4. Test feasibility
5. Result: Novel approach
```

See @references/collision-zones.md

### Validate Architecture

```
1. Pick scale dimension (volume, speed, users, etc.)
2. Test minimum: 1000x smaller/faster
3. Test maximum: 1000x bigger/slower
4. Identify what breaks
5. Result: Fundamental limits exposed
```

See @references/scale-game.md

## Decision Tree

**Start here when stuck:**

```
Are you stuck on:

1. COMPLEXITY (same thing 5+ ways, special cases)
   → Use Simplification Cascades
   
2. INNOVATION (no fitting approach, need breakthrough)
   → Use Collision Zone Thinking
   
3. REPETITION (same pattern in 3+ places)
   → Use Meta-Pattern Recognition
   
4. SCALE (will this work in production?)
   → Use Scale Game
   
5. ASSUMPTIONS (feels forced, "must be this way")
   → Use Inversion Exercise
   
6. UNCLEAR (which technique to use?)
   → Read @references/when-stuck.md for detailed dispatch
```

## Key Principles

1. **Match technique to problem type** - Different stuck needs different approach
2. **Test at extremes** - Normal scales hide fundamental truths
3. **Extract universal patterns** - If it appears 3+ times, it's a principle
4. **Simplify aggressively** - One insight can eliminate 10 components
5. **Question assumptions** - The opposite might reveal the truth
6. **Force collisions** - Unrelated concepts spark innovation

## Real-World Examples

### Simplification Cascade
**Before:** 5 different authentication flows (OAuth, API key, JWT, session, basic)
**Insight:** "Everything is token validation"
**After:** 1 unified token validator + adapters

### Collision Zone
**Problem:** Slow data pipeline
**Collision:** "What if we treated data like streaming video?"
**Result:** Adaptive bitrate-style compression based on consumer capacity

### Meta-Pattern
**Observed:** Retries in HTTP, DB, queue, file system
**Abstracted:** "Exponential backoff with jitter"
**Applied:** Unified retry policy library

### Scale Game
**Question:** Will this work at 1M users?
**Test:** Simulate 1 user → works. 1B users → timeout.
**Discovery:** N² algorithm hidden in "simple" lookup
**Fix:** Add index, now O(log n)

### Inversion
**Assumption:** "Must validate input when received"
**Inversion:** "What if we never accepted invalid input?"
**Result:** Type system + schemas prevent invalid data at compile time

## Integration

Works with:
- **debugging** - Use these when systematic debugging doesn't reveal root cause
- **sequential-thinking** - Apply these techniques within thinking branches
- **validate-plan** - Use scale-game and inversion to stress-test plans

---

**Quick Start:**

1. Read @references/when-stuck.md for dispatch logic
2. Pick the technique matching your stuck-type
3. Follow that technique's specific process
4. If still stuck, try combining techniques

**Remember:** Different problems need different tools. Match the technique to the symptom.