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

Match technique to problem type - Different stuck needs different approach
Test at extremes - Normal scales hide fundamental truths
Extract universal patterns - If it appears 3+ times, it's a principle
Simplify aggressively - One insight can eliminate 10 components
Question assumptions - The opposite might reveal the truth
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:

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

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