playbooks

home / skills / yousufjoyian / claude-skills / when-stuck

when-stuck skill

/problem-solving/when-stuck

This skill helps you quickly identify the appropriate problem-solving technique when you're stuck, enabling faster resolution and better debugging.

This is most likely a fork of the when-stuck skill from mamba-mental
npx playbooks add skill yousufjoyian/claude-skills --skill when-stuck

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

Files (1)
SKILL.md
3.9 KB
---
name: when-stuck
description: Dispatch to the right problem-solving technique based on how you're stuck
---

# When Stuck - Problem-Solving Dispatch

## Overview

Different stuck-types need different techniques. This skill helps you quickly identify which problem-solving skill to use.

**Core principle:** Match stuck-symptom to technique.

## Quick Dispatch

```dot
digraph stuck_dispatch {
    rankdir=TB;
    node [shape=box, style=rounded];

    stuck [label="You're Stuck", shape=ellipse, style=filled, fillcolor=lightblue];

    complexity [label="Same thing implemented 5+ ways?\nGrowing special cases?\nExcessive if/else?"];
    innovation [label="Can't find fitting approach?\nConventional solutions inadequate?\nNeed breakthrough?"];
    patterns [label="Same issue in different places?\nFeels familiar across domains?\nReinventing wheels?"];
    assumptions [label="Solution feels forced?\n'This must be done this way'?\nStuck on assumptions?"];
    scale [label="Will this work at production?\nEdge cases unclear?\nUnsure of limits?"];
    bugs [label="Code behaving wrong?\nTest failing?\nUnexpected output?"];

    stuck -> complexity;
    stuck -> innovation;
    stuck -> patterns;
    stuck -> assumptions;
    stuck -> scale;
    stuck -> bugs;

    complexity -> simp [label="yes"];
    innovation -> collision [label="yes"];
    patterns -> meta [label="yes"];
    assumptions -> invert [label="yes"];
    scale -> scale_skill [label="yes"];
    bugs -> debug [label="yes"];

    simp [label="skills/problem-solving/\nsimplification-cascades", shape=box, style="rounded,filled", fillcolor=lightgreen];
    collision [label="skills/problem-solving/\ncollision-zone-thinking", shape=box, style="rounded,filled", fillcolor=lightgreen];
    meta [label="skills/problem-solving/\nmeta-pattern-recognition", shape=box, style="rounded,filled", fillcolor=lightgreen];
    invert [label="skills/problem-solving/\ninversion-exercise", shape=box, style="rounded,filled", fillcolor=lightgreen];
    scale_skill [label="skills/problem-solving/\nscale-game", shape=box, style="rounded,filled", fillcolor=lightgreen];
    debug [label="skills/debugging/\nsystematic-debugging", shape=box, style="rounded,filled", fillcolor=lightyellow];
}
```

## Stuck-Type → Technique

| How You're Stuck | Use This Skill |
|------------------|----------------|
| **Complexity spiraling** - Same thing 5+ ways, growing special cases | skills/problem-solving/simplification-cascades |
| **Need innovation** - Conventional solutions inadequate, can't find fitting approach | skills/problem-solving/collision-zone-thinking |
| **Recurring patterns** - Same issue different places, reinventing wheels | skills/problem-solving/meta-pattern-recognition |
| **Forced by assumptions** - "Must be done this way", can't question premise | skills/problem-solving/inversion-exercise |
| **Scale uncertainty** - Will it work in production? Edge cases unclear? | skills/problem-solving/scale-game |
| **Code broken** - Wrong behavior, test failing, unexpected output | skills/debugging/systematic-debugging |
| **Multiple independent problems** - Can parallelize investigation | skills/collaboration/dispatching-parallel-agents |
| **Root cause unknown** - Symptom clear, cause hidden | skills/debugging/root-cause-tracing |

## Process

1. **Identify stuck-type** - What symptom matches above?
2. **Load that skill** - Read the specific technique
3. **Apply technique** - Follow its process
4. **If still stuck** - Try different technique or combine

## Combining Techniques

Some problems need multiple techniques:

- **Simplification + Meta-pattern**: Find pattern, then simplify all instances
- **Collision + Inversion**: Force metaphor, then invert its assumptions
- **Scale + Simplification**: Extremes reveal what to eliminate

## Remember

- Match symptom to technique
- One technique at a time
- Combine if first doesn't work
- Document what you tried

Overview

This skill dispatches you to the right problem-solving technique based on how you are stuck. It maps common stuck-types (complexity, innovation block, recurring patterns, assumptions, scale worries, and bugs) to targeted techniques so you can pick an approach that fits the symptom. The goal is faster recovery and clearer next steps.

How this skill works

You identify which symptom best matches your situation, then the skill recommends a focused technique to load and apply. It covers simplification for spiraling complexity, collision-zone thinking for innovation, meta-pattern recognition for recurring issues, inversion for assumption traps, scale exercises for production uncertainty, and systematic debugging for broken code. If one technique doesn’t resolve the problem, it suggests trying another or combining techniques.

When to use it

  • When the same feature is implemented many ways and special cases multiply
  • When conventional approaches fail and you need a breakthrough idea
  • When you see the same problem across different modules or projects
  • When you feel constrained by unexamined assumptions or “this must be done” thinking
  • When you’re unsure whether a design will scale to production or handle edge cases
  • When tests fail, outputs are unexpected, or behavior is incorrect

Best practices

  • Start by clearly describing the symptom before choosing a technique
  • Apply one technique at a time to isolate effects, then combine as needed
  • Document each technique you try and the outcomes to avoid repeating work
  • Prefer simplification early when complexity is growing to reduce cognitive load
  • Use parallel investigation only when problems are independent and can be safely split

Example use cases

  • Refactor a codebase where similar logic exists in five different modules — use simplification-cascades
  • You’re blocked on a novel algorithm — apply collision-zone-thinking to force new analogies
  • Multiple teams keep reinventing a scheduler — use meta-pattern-recognition to extract a shared solution
  • You’re crowding around a presumed constraint — run an inversion-exercise to question the premise
  • A feature works in tests but may fail in production under load — play the scale-game to surface edge cases
  • A failing test with unclear cause — follow systematic-debugging then root-cause-tracing

FAQ

What if multiple stuck-types apply?

Try the most dominant symptom first, then combine complementary techniques (for example simplification + meta-pattern). Document each attempt.

How long should I spend on one technique before switching?

Give a focused, time-boxed effort (typically 30–90 minutes). If you make no progress, switch or add a second method with a fresh perspective.