Unstuck

/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 — 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.

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:

markdownCopy code
# 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):

markdownCopy code
- 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.
• pm — 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.