when-stuck

Maps six common blocker types to recommended problem-solving techniques via a decision graph.

130|8|Updated Jan 23, 2026
One-click install
npx skills add https://github.com/sandgardenhq/sgai --skill when-stuck-sandgardenhq
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: when-stuck
Source: https://github.com/sandgardenhq/sgai/tree/main/cmd/sgai/skel/.sgai/skills/problem-solving/when-stuck
Command: npx skills add https://github.com/sandgardenhq/sgai --skill when-stuck-sandgardenhq

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

When you're stuck on a problem, this Skill quickly identifies the type of blockage and points you to the most effective problem‑solving technique, saving time and effort.

Core Features & Use Cases

  • Symptom‑to‑technique mapping: A decision graph that matches six common stuck scenarios (complexity, innovation, patterns, assumptions, scale, bugs) to specialized sub‑skills.
  • Technique recommendation: Returns the path to the appropriate skill such as simplification‑cascades, collision‑zone thinking, or systematic debugging.
  • Combining methods: Guides users on how to blend multiple techniques when a single approach isn’t enough. Use case example: A developer facing a complex codebase can invoke this Skill to get directed to the simplification‑cascades technique.

Quick Start

Identify how you're stuck and ask the when‑stuck skill to recommend the appropriate problem‑solving technique.

Frequently Asked Questions about when-stuck

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I find the right debugging technique when I'm stuck on a software problem?

Problem-solving techniques are dispatched by matching your current symptoms to a decision graph covering complexity, innovation gaps, pattern repetition, assumption traps, scaling doubts, and debugging issues. This directs you to a specialized sub-skill for rapid technique selection.

What is the best way to choose a problem-solving method for a complex codebase?

Choosing a problem-solving method for a complex codebase involves identifying your specific blockage type through a symptom-to-technique mapping decision graph. This process directs you to targeted techniques like simplification-cascades to handle the complexity effectively.

How do I combine multiple problem-solving techniques when a single approach isn't enough?

You can combine multiple problem-solving techniques by following the Skill's guidance on blending methods when a single approach falls short. It provides a decision graph that links your current symptoms to specific sub-skills, allowing you to integrate multiple techniques systematically.

Does this problem-solving dispatch model handle assumption traps and scaling doubts?

Yes, this problem-solving dispatch model explicitly handles assumption traps and scaling doubts. It applies a decision graph to six common stuck scenarios, including complexity, innovation gaps, pattern repetition, scaling doubts, and debugging issues, to recommend the appropriate technique.

Why does my current debugging approach fail to resolve recurring pattern repetition issues?

Your debugging approach may fail because pattern repetition issues require specialized problem-solving techniques rather than standard debugging. This Skill identifies pattern repetition as a distinct stuck scenario and dispatches you to targeted sub-skills designed to break those specific cycles.