GGPrompts 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.