Skip to main content
skill CX Codex

unstuck — Claude Code skill: what it does and how to install

unstuck — a skill that fires when a task hits a wall: it classifies the kind of "no" you ran into, then pushes it through lateral-thinking techniques until real workarounds appear.

MIT 332 installs ★ 932 updated 2026-11-11

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add coreyhaines31/makerskills --skill unstuck -a claude-code
Open on GitHub

What unstuck does

unstuck works a blockage through seven steps. It first collects context in a single message: the goal, what blocks it, what was tried, and who or what said no. Then it sorts the wall into types — unexamined assumption, wrong framing, a gatekeeper's refusal, a tool limitation, a resource gap, or actual physics. The type picks the crowbar: assumption autopsy, inversion, first principles, constraint toggling, analogical transfer, and more from references/techniques.md.

One hard rule: at least 10 genuinely different angles before any evaluation, and three flavors of "ask again nicer" count as one. Angles then get triaged into try-now, needs-research (routed to /deep-research), wild-but-cheap, and dead. One to three survivors get a concrete next action each; mutually exclusive options go to /decide. If the wall turns out to be physics, the skill says so and recommends rerouting the goal instead of faking a workaround.

An agent fast path exists too: when an API can't do what's needed, an approach has failed twice, or a "that's not possible" sentence is forming, the skill runs before the agent reports a dead end. Resolved walls get archived under ~/.config/makerskills/unstuck/archive/ with an index file, which over time becomes a greppable library of which techniques crack your walls.

What it helps with

  • break down a task that looks impossible because an API or tool won't cooperate
  • re-verify inherited assumptions that block the solution
  • generate 10+ distinct workarounds before judging any of them
  • reroute the goal honestly when the wall is a real constraint
  • build a searchable archive of past roadblocks and what cracked them

Example prompts for the agent

  • I'm stuck: the API doesn't support what I need
  • We've tried everything, this is impossible — run /unstuck on it
  • We hit a wall, find a way around this

How to install unstuck

1Skills CLI (Vercel)

npx skills add coreyhaines31/makerskills --skill unstuck -a claude-code

2Manually: put the files in place

~/.claude/skills/unstuck/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/unstuck/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about unstuck

How do I install unstuck in Claude Code?

Run npx skills add coreyhaines31/makerskills --skill unstuck -a claude-code. The skill lands at ~/.claude/skills/unstuck/SKILL.md.

What does the unstuck skill do?

It takes a task that seems impossible, classifies the type of roadblock, and applies matching lateral-thinking techniques. The output is one to three viable angles with next actions, or an honest call to reroute the goal.

How is unstuck different from just asking for workarounds?

It enforces structure: assumption autopsy first, at least 10 different-in-kind angles with no judging, then triage. A fast path also runs automatically before the agent reports a dead end.

Source text

SKILL.md · MIT
---
name: unstuck
description: "When a solution seems impossible and the path forward is blocked. Refuses to take no for an answer: classifies what kind of \"no\" you hit, then runs lateral-thinking techniques (assumption autopsy, inversion, first principles, constraint toggling, analogical transfer, and more) until the wall cracks or is proven load-bearing. Generates at least 10 angles before evaluating any. AGENTS: use this on yourself when an API doesn't support what you need, an approach has failed twice, or a \"that's not possible\" sentence is forming — run the fast path BEFORE reporting a dead end. Archives walls to ~/.config/makerskills/unstuck/archive/. Sits upstream of decide. Triggers on \"/unstuck,\" \"I'm stuck,\" \"this seems impossible,\" \"we hit a wall,\" \"there's no way to,\" \"they said no,\" \"dead end,\" \"out of options,\" \"I've tried everything,\" \"work around this.\""
metadata:
  version: 0.1.1
---

# /unstuck — The roadblock antidote

Turns "impossible" into angles. Classifies the wall, runs the right lateral-thinking techniques against it, and doesn't stop at the first mediocre workaround. Output is either a set of viable angles with next actions — or an honest "this wall is load-bearing, reroute the goal."

**Two modes:**
- **User-invoked** — someone is stuck and asks. Full 7-step workflow below.
- **Agent fast path** — YOU (the agent) hit the wall mid-task. See [Agent fast path](#agent-fast-path) — run it before telling the user something can't be done.

## The mental model: walls have types, and the type picks the crowbar

"Impossible" is a claim, not a fact. It almost always decompiles into something weaker: *expensive*, *against the rules*, *nobody's done it*, *I don't know how*. Only *actually impossible* (physics, math, arithmetic) ends the session — and it ends it honestly.

| Wall type | What "impossible" actually means | Lead techniques (see `references/techniques.md`) |
|---|---|---|
| **Assumption** | An inherited belief nobody re-verified | T1 assumption autopsy, T3 first principles |
| **Framing** | The goal is stated in a way that excludes the answer | T4 altitude shift, T2 inversion, T5 work backwards |
| **Gatekeeper** | A person/org said no | T10 interrogate the no, T6 analogical transfer |
| **Tool/tech** | "X doesn't support Y" | T9 SCAMPER (substitute the primitive), T6 analogical transfer |
| **Resource** | Not enough time/money/people | T7 constraint toggling, T8 provocation |
| **Physics/math** | Actually impossible (rare) | Honest exit — reroute the goal, the wall is load-bearing |

## Step 1 — Capture the wall

Get from the user (one structured message, don't round-trip):

- **The goal** — what are you ultimately trying to do? (Not the blocked step — the job it serves.)
- **The wall** — what exactly blocks it?
- **Attempts** — what have you already tried?
- **The source of the no** — who or what said no? Physics? A vendor's docs? A person? An error message? Your own assumption?
- **Stakes + deadline** — how much does breaking this wall matter, by when?

If the user says "I've tried everything," ask for the list. "Everything" is usually 2–3 things.

## Step 2 — Classify the wall

Use the taxonomy above. State the classification and why. Two rules:

1. **Decompile the word "impossible."** Restate the wall without it: "expensive," "undocumented," "they refused," "I don't know how." The restatement usually names the wall type.
2. **Restate the problem at two altitudes** before proceeding — one level more abstract (*what job is this serving?*) and one level more concrete (*what literally fails, at which exact step?*). Many walls dissolve at a different altitude; if one does, say so and skip to Step 6.

## Step 3 — Assumption autopsy (always runs)

Run T1 from `references/techniques.md` regardless of wall type: enumerate every assumption embedded in the problem statement, mark each **verified fact** vs **inherited belief**, and attack the beliefs. Most walls die here — the ones that don't are at least correctly framed for Step 4.

## Step 4 — Run the triaged techniques

Pick 2–3 more techniques by wall type (lead techniques in the table; full triage guidance in `references/techniques.md`). For each, generate 2–3 angles.

**Rules of generation:**
- **Quantity gate: minimum 10 angles total before evaluating any.** The first workaround is usually mediocre. No judging, no feasibility talk, no "but" during generation.
- Angles must be **different in kind**, not variations — three flavors of "ask again nicer" is one angle.
- Wild angles are welcome at this stage; they get filtered in Step 5, and they often seed the viable ones.

## Step 5 — Triage the angles

Sort every angle into:

- **Try now** — feasible with what's in hand; has a concrete first action
- **Needs research** — viable if an unknown checks out → route to `/deep-research`
- **Wild but worth 30 min** — low odds, trivial cost, asymmetric payoff
- **Dead** — violates a real constraint (say which)

## Step 6 — Commit

- Pick **1–3 angles** with a concrete next action each.
- If 2+ viable angles are mutually exclusive → hand the fork to `/decide`.
- If NOTHING survived triage and the wall is physics/math class: say so plainly. **"The wall is load-bearing — reroute the goal" is a legitimate, successful output.** Recommend what the rerouted goal looks like.

## Step 7 — Archive

Archives live in `${MAKERSKILLS_CONFIG:-$HOME/.config/makerskills}/unstuck/archive/` (create the directory if missing). Never write archives inside the skill's own folder — skill installs and upgrades re-sync from source and wipe anything saved there.

Write to `<archive dir>/<YYYY-MM-DD>-<slug>.md`:

```markdown
# Wall: <one-line>

**Date:** YYYY-MM-DD
**Invoked by:** user | agent
**Wall type:** assumption / framing / gatekeeper / tool / resource / physics
**Goal it blocked:** <one line>

## The wall as stated
<verbatim>

## The wall decompiled
<restated without "impossible">

## Assumptions attacked
- <belief> → <held / broke>

## Techniques run
T1, T4, T7 — <one line on what each surfaced>

## Angles (all of them)
1. <angle> — try now / research / wild / dead
2. …

## Committed
**<the angle(s) chosen>** — next action: <concrete step>
(or: "Wall is load-bearing — rerouted goal to <X>")

## Outcome (fill in later)
<did the angle work?>
```

Append to `<archive dir>/INDEX.md` (create if missing):

```markdown
- 2026-07-14 — [<wall>](./<filename>.md) — <type> — **<committed angle or "rerouted">**
```

Over time this becomes a pattern library: grep it to learn which techniques actually crack *your* walls, and which wall types recur (a recurring wall is usually one unexamined assumption upstream).

## Agent fast path

For when YOU (the agent) hit the wall mid-task. Trigger condition: an API/tool doesn't support what's needed, an approach has failed twice, or you notice a "that's not possible," "unfortunately," or "the only option is" sentence forming in your response.

**Before reporting a dead end to the user, run inline (no interactive capture — you already have the wall in context):**

1. **Classify** the wall (taxonomy above) — one line.
2. **Autopsy** — list the 3–5 assumptions in your framing; mark inherited beliefs. ("The cursor must be a text character." "This must happen client-side." "The API is the only way in.")
3. **Run 2 techniques** matched to the wall type — generate 5+ angles minimum for inline recoveries. **If you end up reporting a dead end to the user, the full 10-angle gate applies first** — a dead-end report is exactly the moment the gate exists for.
4. **Then either:**
   - a viable angle exists → **proceed with it** (tell the user the wall you hit and the angle you took), or
   - nothing viable → report the dead end **with the angle inventory attached**: what you tried, what you considered, why each died. Never a naked "that's not supported."
5. **Archive** the run (Step 7 format, `Invoked by: agent`) when the wall was nontrivial — skip archiving for sub-minute walls.

The success metric: the user stops seeing dead-end reports without tried-angles receipts.

## Composes with

- `decide` — downstream: 2+ mutually exclusive viable angles become a `/decide` fork. Upstream: decide's Q19 ("what missing info would change it?") can route here when the missing thing is an *option*, not information.
- `deep-research` — "needs research" angles route there; the brief comes back and re-enters Step 5.
- `business-brainstorm` — its "angle to steal" move on Kill verdicts is this skill applied to business ideas.
- `project-manager` — a committed angle becomes a board task.
- `second-brain` — archive entries can compile into a "walls I've broken" wiki page.

## Guardrails

- **A no from consent, law, or ethics is a real no.** This skill routes around technical and imagination walls — not people's boundaries. If the wall is "they said no and meant it," the move is interrogating whether there's a *different door they'd happily open* (T10), never pushing on the closed one.
- **Time-box: 20–40 minutes.** This is a crowbar, not a philosophy seminar. If the sprint ends without a crack, archive what was tried and either schedule a revisit or reroute.
- **Honest exit beats toxic positivity.** Declaring a wall load-bearing after a real attempt is a win — it converts an ambient frustration into a clear reroute.

## Notes on quality

- **The restatement is half the work.** Most "impossible" problems are impossible *as stated*. Two-altitude restatement (Step 2) before any technique — always.
- **Don't let the quantity gate become theater.** 10 angles that are secretly 3 angles in costumes fail the gate. Different in kind.
- **Attempts list beats attempts vibe.** "I've tried everything" → get the actual list. The gap between "everything" and the list is where the answer usually lives.
- **Archive even the failures.** A wall that didn't crack today, with its angle inventory, is a 5-minute revisit when the landscape changes — instead of a from-scratch session.

© coreyhaines31 · MIT · coreyhaines31/makerskills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set20

The whole set →
slide-deck Builds React/Next.js slide decks: draft from a brief, edit an existing deck, convert PPTX, export to HTML, PDF or a Vercel URL. CX Codex +1 392installs maker-council maker-council convenes a simulated board of nine well-known founders and operators, from Jason Fried to Naval Ravikant, to stress-test a real business decision. Money, hiring, pricing and kill-or-keep questions are its lane. CX Codex +1 384installs skillify skillify — a skill for Claude Code, Codex, and Cursor that scaffolds, adapts, updates, and evaluates agent instructions directly from conversations, notes, or recordings. CX Codex +1 384installs loopify loopify turns "this task should run periodically" into a working loop, picking the pacing and adding idempotency plus a bail-out. CX Codex +1 383installs paste paste strips ANSI codes, box-drawing chars, and terminal prompt artifacts from clipboard content, then reformats for Slack, Notion, Twitter, LinkedIn, email, GitHub, or plain text. CX Codex +1 380installs toolify toolify is a Claude Code skill that asks about an integration and writes its client wrapper, environment variables, and webhook handler. It connects Stripe, Supabase, or an MCP server to a project. CX Codex +1 380installs pm pm keeps a kanban board per business or project and sorts the backlog with the Eisenhower matrix. Useful when several boards compete for your attention. CX Codex +1 365installs ingest This Claude Code skill turns call transcripts, messages, and meeting notes into decisions and action items. Run /ingest to also file GitHub issues and draft a reply. CX Codex +1 134installs

Project sponsors

Companies that keep this analytics open