playbooks

home / skills / samhvw8 / dotfiles / problem-solving

problem-solving skill

/dot_ccp/hub/skills/problem-solving

This skill helps you resolve complex problems by applying simplification, pattern recognition, and inversion to break through blocks and scale solutions.

npx playbooks add skill samhvw8/dotfiles --skill problem-solving

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

Files (8)
SKILL.md
4.6 KB
---
name: problem-solving
description: "Systematic problem-solving techniques for stuck-ness. Techniques: simplification cascade (complexity spirals), collision-zone thinking (innovation blocks), meta-pattern recognition (recurring issues), inversion exercise (assumption constraints), scale game (uncertainty). Actions: simplify, analyze, recognize patterns, invert assumptions, scale thinking. Keywords: problem solving, complexity spiral, innovation block, stuck, simplification, meta-pattern, assumption inversion, scale uncertainty, breakthrough thinking, root cause, systematic analysis, Microsoft Amplifier, debugging approach, creative solution. Use when: complexity spiraling, hitting innovation blocks, seeing recurring patterns, constrained by assumptions, uncertain about scale, generally stuck on problems."
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 provides systematic problem-solving techniques for when you feel stuck, face spiraling complexity, or need breakthrough thinking. It groups five practical methods—simplification cascades, collision-zone thinking, meta-pattern recognition, inversion exercises, and the scale game—so you can match symptoms to targeted actions quickly. The goal is rapid insight, repeatable analysis, and clear next steps toward a workable solution.

How this skill works

Inspect the current failure mode or feeling of stuck-ness and map it to one of the five techniques. Each technique gives a focused action (simplify, collide metaphors, recognize recurring patterns, invert assumptions, or test extremes) and a short process to produce diagnostic insights. Apply one technique, document outcomes, and iterate or combine methods when a single pass isn’t enough.

When to use it

  • When complexity is spiraling: many special cases and branching implementations
  • When conventional approaches hit an innovation block and breakthroughs are needed
  • When the same issue appears across projects or domains, suggesting a pattern
  • When solutions feel forced by hidden assumptions that limit options
  • When uncertainty about scale or production readiness could hide failures
  • When you’re generally stuck and unsure which approach will help

Best practices

  • Start by diagnosing the stuck-type before picking a technique
  • Document hypotheses and lightweight tests so insights are reproducible
  • Favor radical simplification: find one insight that removes multiple parts
  • Use deliberate metaphor collisions to surface non-obvious ideas
  • Test at extreme scales early to reveal brittle assumptions

Example use cases

  • Refactor a codebase with five near-duplicate implementations into a single abstraction
  • Generate a novel product approach by forcing a comparison between unrelated systems
  • Identify a reusable library by recognizing the same error-handling pattern across services
  • Break a blocked design decision by inverting the key assumption and exploring consequences
  • Validate architecture choices by simulating 1000x load and one-off edge conditions

FAQ

How do I pick which technique to try first?

Match the symptom: complexity -> simplification; repeated failures -> meta-pattern; dead-end thinking -> collision-zone; forced rules -> inversion; uncertainty about load or longevity -> scale game.

Can I combine techniques?

Yes—combinations are powerful (e.g., simplify after spotting a meta-pattern, or collide metaphors then invert the new idea). Iterate and document results.