home / skills / jjuidev / jss / problem-solving

problem-solving skill

safe

/.claude/skills/problem-solving

This skill helps you apply systematic problem-solving techniques to identify, simplify, and resolve complex blocks across domains.

npx playbooks add skill jjuidev/jss --skill problem-solving

Review the files below or copy the command above to add this skill to your agents.

Files (8)

SKILL.md

4.1 KB

---
name: Problem-Solving Techniques
description: Apply systematic problem-solving techniques when stuck. Use for complexity spirals, innovation blocks, recurring patterns, assumption constraints, simplification cascades, scale uncertainty.
version: 2.0.0
---

# Problem-Solving Techniques

Systematic approaches for different types of stuck-ness. Each technique targets specific problem patterns.

## When to Use

Apply when encountering:
- **Complexity spiraling** - Multiple implementations, growing special cases, excessive branching
- **Innovation blocks** - Conventional solutions inadequate, need breakthrough thinking
- **Recurring patterns** - Same issue across domains, reinventing solutions
- **Assumption constraints** - Forced into "only way", can't question premise
- **Scale uncertainty** - Production readiness unclear, edge cases unknown
- **General stuck-ness** - Unsure which technique applies

## Quick Dispatch

**Match symptom to technique:**

| Stuck Symptom | Technique | Reference |
|---------------|-----------|-----------|
| Same thing implemented 5+ ways, growing special cases | **Simplification Cascades** | `references/simplification-cascades.md` |
| Conventional solutions inadequate, need breakthrough | **Collision-Zone Thinking** | `references/collision-zone-thinking.md` |
| Same issue in different places, reinventing wheels | **Meta-Pattern Recognition** | `references/meta-pattern-recognition.md` |
| Solution feels forced, "must be done this way" | **Inversion Exercise** | `references/inversion-exercise.md` |
| Will this work at production? Edge cases unclear? | **Scale Game** | `references/scale-game.md` |
| Unsure which technique to use | **When Stuck** | `references/when-stuck.md` |

## Core Techniques

### 1. Simplification Cascades
Find one insight eliminating multiple components. "If this is true, we don't need X, Y, Z."

**Key insight:** Everything is a special case of one general pattern.

**Red flag:** "Just need to add one more case..." (repeating forever)

### 2. Collision-Zone Thinking
Force unrelated concepts together to discover emergent properties. "What if we treated X like Y?"

**Key insight:** Revolutionary ideas from deliberate metaphor-mixing.

**Red flag:** "I've tried everything in this domain"

### 3. Meta-Pattern Recognition
Spot patterns appearing in 3+ domains to find universal principles.

**Key insight:** Patterns in how patterns emerge reveal reusable abstractions.

**Red flag:** "This problem is unique" (probably not)

### 4. Inversion Exercise
Flip core assumptions to reveal hidden constraints. "What if the opposite were true?"

**Key insight:** Valid inversions reveal context-dependence of "rules."

**Red flag:** "There's only one way to do this"

### 5. Scale Game
Test at extremes (1000x bigger/smaller, instant/year-long) to expose fundamental truths.

**Key insight:** What works at one scale fails at another.

**Red flag:** "Should scale fine" (without testing)

## Application Process

1. **Identify stuck-type** - Match symptom to technique above
2. **Load detailed reference** - Read specific technique from `references/`
3. **Apply systematically** - Follow technique's process
4. **Document insights** - Record what worked/failed
5. **Combine if needed** - Some problems need multiple techniques

## Combining Techniques

Powerful combinations:
- **Simplification + Meta-pattern** - Find pattern, then simplify all instances
- **Collision + Inversion** - Force metaphor, then invert its assumptions
- **Scale + Simplification** - Extremes reveal what to eliminate
- **Meta-pattern + Scale** - Universal patterns tested at extremes

## References

Load detailed guides as needed:
- `references/when-stuck.md` - Dispatch flowchart and decision tree
- `references/simplification-cascades.md` - Cascade detection and extraction
- `references/collision-zone-thinking.md` - Metaphor collision process
- `references/meta-pattern-recognition.md` - Pattern abstraction techniques
- `references/inversion-exercise.md` - Assumption flipping methodology
- `references/scale-game.md` - Extreme testing procedures
- `references/attribution.md` - Source and adaptation notes

Overview

This skill teaches systematic problem-solving techniques to get unstuck, reduce complexity, and find breakthrough solutions. It maps common failure modes to targeted methods and shows how to combine techniques for stronger results. Use it to turn recurring headaches and scale uncertainty into clear experiments and design decisions.

How this skill works

Inspect the symptom of being stuck, match it to a focused technique, and run a short, repeatable process that surfaces insights. Techniques include simplification cascades, metaphor collisions, pattern abstraction, assumption inversion, and extreme-scale testing. Document outcomes and iterate, combining techniques when a single approach falls short.

When to use it

When complexity spirals with many special cases and tangled branches
When conventional approaches fail and you need breakthrough thinking
When the same problem keeps reappearing across projects
When assumptions feel fixed and you can’t question the premise
When uncertainty about production scale or edge cases blocks progress
When you’re generally unsure which method to try next

Best practices

Start by classifying the stuck symptom before applying any technique
Run quick, bounded experiments—prefer falsifying tests over long builds
Document what you try and what changes averted the problem
Combine complementary techniques (e.g., simplification + pattern recognition)
Test at extremes to reveal hidden failure modes and discard fragile ideas
Favor extracting a single insight that removes multiple components

Example use cases

Consolidating five parallel implementations into one general solution
Generating radical product ideas by forcing metaphors from other domains
Finding a reusable abstraction after spotting the same pattern in three projects
Revealing a hidden assumption by inverting the problem statement
Validating whether a prototype will behave at 1000x scale before launch

FAQ

What if I don’t know which technique applies?

Use the dispatch flow: describe the symptom, then match to the nearest technique; when in doubt, run a quick inversion or scale test to expose constraints.

Can I combine techniques?

Yes. Combining methods—like simplification after spotting a meta-pattern—often yields stronger, faster results than using one alone.