Problem-solving frameworks for breakthrough thinking - collision zones, simplification cascades, meta-patterns, scale testing, inversion, and dispatch guide...
Systematic techniques for breaking through complex problems, finding simplifying insights, and matching the right approach to your specific type of stuck.
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 |
Decision tree to quickly identify which problem-solving technique to use based on your specific stuck-symptom.
"What if we treated X like Y?" - Deliberate metaphor-mixing for breakthrough innovation.
Examples:
"If this is true, we don't need X, Y, or Z" - One insight that eliminates multiple components.
Look for:
When the same pattern appears in 3+ domains, extract the universal principle.
Examples:
1000x bigger/smaller, instant/year-long - extremes expose fundamental truths.
Test dimensions:
"What if the opposite were true?" - Reveals hidden constraints and alternatives.
Examples:
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
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
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
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
Before: 5 different authentication flows (OAuth, API key, JWT, session, basic) Insight: "Everything is token validation" After: 1 unified token validator + adapters
Problem: Slow data pipeline Collision: "What if we treated data like streaming video?" Result: Adaptive bitrate-style compression based on consumer capacity
Observed: Retries in HTTP, DB, queue, file system Abstracted: "Exponential backoff with jitter" Applied: Unified retry policy library
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)
Assumption: "Must validate input when received" Inversion: "What if we never accepted invalid input?" Result: Type system + schemas prevent invalid data at compile time
Works with:
Quick Start:
Remember: Different problems need different tools. Match the technique to the symptom.
