problem-solving

5 techniques for different problem types. Use when stuck or facing complex challenges.

⭐3stars🔀2forks📁View on GitHub🕐Updated Jan 8, 2026

When & Why to Use This Skill

This Claude skill provides a comprehensive framework of five advanced problem-solving techniques—Simplification Cascades, Collision-Zone Thinking, Meta-Pattern Recognition, Inversion Exercise, and Scale Game. It is designed to help developers and architects navigate complex technical challenges, overcome innovation blocks, and optimize system architecture through structured mental models.

Use Cases

  • Debugging multi-layered system failures (e.g., auth + caching + logging) by stripping complexity to identify the core issue layer-by-layer.
  • Breaking through creative blocks in product design by synthesizing concepts from unrelated domains like gaming and psychology to find novel solutions.
  • Eliminating recurring technical debt by identifying and addressing underlying meta-patterns that cause similar issues across different database tables or services.
  • Overcoming tunnel vision in software design by inverting core assumptions to discover more efficient or real-time architectural paths.
  • Ensuring production readiness and system reliability by stress-testing designs at 10x to 1000x current load to proactively identify future bottlenecks.
nameproblem-solving
description"5 techniques for different problem types. Use when stuck or facing complex challenges."
autoInvokefalse
priorityhigh
modelsonnet

Problem Solving Techniques

Version: 1.0.0 Use When: Stuck, need breakthrough, or evaluating approaches


5 Techniques

techniques[5]{name,when,approach}:
  Simplification Cascades,Complexity spiraling / 5+ attempts failed,Strip to minimal → rebuild
  Collision-Zone Thinking,Innovation blocks / need breakthrough,Combine unrelated concepts
  Meta-Pattern Recognition,Same issue across domains,Find underlying pattern
  Inversion Exercise,Forced into "only way" thinking,Ask "what if opposite?"
  Scale Game,Production readiness unclear,Test at 10x / 100x / 1000x

1. Simplification Cascades

When: Complexity spiraling, 5+ implementations tried

Process:

1. Remove ALL features except core
2. Make it work with hardcoded values
3. Add ONE thing back
4. Repeat until issue appears
5. Fix at that layer

Example:

Problem: Auth + caching + retry + logging all broken

Simplify:
1. Remove retry, logging, caching → just auth
2. Auth works? Yes → add caching
3. Caching breaks it → found the issue
4. Fix caching layer
5. Re-add retry, logging

2. Collision-Zone Thinking

When: Need creative breakthrough, conventional approaches failed

Process:

1. List unrelated domains
2. Find principles from each
3. Combine into novel solution

Example:

Problem: Users abandoning checkout

Domains: Gaming + Psychology + Logistics

Collision:
- Gaming: Progress bars, achievements
- Psychology: Loss aversion
- Logistics: Just-in-time delivery

Solution: "Your items are reserved for 10 min" +
          progress indicator +
          "3 people viewing this item"

3. Meta-Pattern Recognition

When: Same issue keeps appearing in different forms

Process:

1. List all similar issues
2. Find what they share
3. Fix the meta-pattern

Example:

Issues:
- Users table query slow
- Orders table query slow
- Products table query slow

Meta-pattern: All queries filter by date without index

Fix: Add date indexes to all tables

4. Inversion Exercise

When: Stuck in "only way" thinking

Process:

1. State current assumption
2. Ask: "What if the opposite?"
3. Explore inverted approach

Example:

Assumption: "We need to cache API responses"

Inversion: "What if we never cache?"
→ Forces real-time design
→ Discovers: Most data doesn't change
→ Solution: Cache-first with invalidation
   (opposite of assumed API-first)

5. Scale Game

When: Production readiness unclear

Process:

1. Test at 10x current load
2. Test at 100x
3. Test at 1000x
4. Find breaking point
5. Design for 10x actual need

Example:

Current: 100 users/day

Scale test:
- 1,000: Works fine
- 10,000: DB connection pool exhausted
- 100,000: Memory OOM

Breaking point: 10,000 users
Design for: 1,000 (10x buffer)
Fix: Connection pooling + memory optimization

Decision Matrix

decision[5]{symptom,technique,model}:
  "Tried everything",Simplification Cascades,sonnet
  "Need creative idea",Collision-Zone Thinking,opus
  "Keeps happening",Meta-Pattern Recognition,sonnet
  "No other way",Inversion Exercise,sonnet
  "Will it scale?",Scale Game,sonnet

Quick Reference

Stuck → Simplify first
Creative block → Collision zones
Recurring issues → Meta-patterns
Tunnel vision → Invert assumptions
Scaling fears → Scale game

Invoke: Use when conventional debugging fails or need breakthrough.