home / skills / mamba-mental / agent-skill-manager / when-stuck

This skill quickly identifies your stuck-type and dispatches the appropriate problem-solving technique to help you progress.

npx playbooks add skill mamba-mental/agent-skill-manager --skill when-stuck

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

Files (1)
SKILL.md
4.0 KB
---
name: When Stuck - Problem-Solving Dispatch
description: Dispatch to the right problem-solving technique based on how you're stuck
when_to_use: when stuck and unsure which problem-solving technique to apply for your specific type of stuck-ness
version: 1.1.0
---

# 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 most effective problem-solving technique based on how you are stuck. It maps common stuck-types (complexity, innovation blocks, recurring patterns, assumptions, scale concerns, and bugs) to targeted techniques. Use it to quickly pick a focused approach and reduce wasted effort.

How this skill works

You identify which symptom best matches your situation, then load the recommended technique and follow its steps. If the first technique doesn't resolve the issue, try a different one or combine techniques. The skill encourages one focused attempt at a time and logging what you tried.

When to use it

  • When complexity is spiraling and there are many ad-hoc special cases
  • When conventional approaches fail and you need a breakthrough
  • When the same issue appears across different modules or projects
  • When a solution feels forced and assumptions may be blocking progress
  • When you need to validate production-scale behavior or edge cases
  • When code is misbehaving, tests fail, or the root cause is unknown

Best practices

  • Match a clear symptom to a single technique before applying it
  • Document what you tried and the outcome to avoid repeating work
  • Start with simplification when complexity is the main pain
  • Combine techniques deliberately (e.g., simplify then generalize)
  • Keep experiments small and reproducible when testing scale or fixes

Example use cases

  • A feature has five slightly different implementations—use simplification-cascades to unify them
  • Stalled design where standard patterns don't fit—try collision-zone-thinking to generate novel approaches
  • Multiple modules show similar bugs—use meta-pattern-recognition to find the shared flaw
  • You're stuck because you assume a constraint is fixed—run an inversion-exercise to flip the premise
  • Unsure if a prototype will scale—apply the scale-game to test extremes and identify limits

FAQ

What if more than one stuck-type applies?

Pick the clearest dominant symptom and apply that technique first; combine techniques if the single approach is insufficient.

How long should I spend on one technique before switching?

Give a focused, time-boxed attempt (e.g., 30–90 minutes) and record what changed before trying a different technique.