Claude Skill

unstuck

When a solution seems impossible and the path forward is blocked — the antidote to any roadblock or wall. Refuses to take no for an answer: classifies what kind of "no" you actually hit, then runs targeted lateral-thinking techniques (assumption autopsy, inversion, first principl

LLM Mart · 0 points · 7 0 0

Virus-scanned Reviewed automatically before listing.

Full trust report

Download coreyhaines31-makerskills-skills_unstuck-1868b81.zip · 9 KB

coreyhaines31/makerskills 819 67 forks MIT Updated 21d ago

Part of coreyhaines31/makerskills — 18 skills

Install

skills CLI npx skills add https://github.com/coreyhaines31/makerskills/tree/main/skills/unstuck

Claude Code

claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install coreyhaines31-makerskills@llmmart

Git git clone https://github.com/coreyhaines31/makerskills.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole coreyhaines31/makerskills collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

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

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:

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.
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:

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

- 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):

Classify the wall (taxonomy above) — one line.
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.")
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.
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."
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.

Files (makerskills)

references

techniques.md 9.1 KB

# Technique inventory — the 10 crowbars

Each technique: when it fires (by wall type), the moves, and a worked example. Run 3–4 per session (T1 always runs). Generate 2–3 angles per technique; don't evaluate while generating.

## Triage by wall type

| Wall type | Always | Lead | Backup |
|---|---|---|---|
| Assumption | T1 | T3 | T5 |
| Framing | T1 | T4, T2 | T5 |
| Gatekeeper | T1 | T10 | T6 |
| Tool/tech | T1 | T9, T6 | T3 |
| Resource | T1 | T7 | T8 |
| Physics/math | T1 (confirm it's real) | — honest exit: reroute the goal | T4 (the rerouted goal often hides one altitude up) |
| Unclear / mixed | T1 | T4 | T8 (provocation shakes loose a classification) |

---

## T1 — Assumption autopsy *(always runs)*

**Fires on:** every wall. Most walls die here.

**Moves:**
1. Write the problem statement verbatim.
2. Enumerate every assumption embedded in it — including the invisible ones (the nouns chosen, the actor assumed, the sequence implied, the tool presumed).
3. Mark each: **verified fact** (you checked, recently, yourself) vs **inherited belief** (docs said, someone said, it's always been that way, you assumed).
4. For each belief: what would it cost to test it right now? Test the cheap ones immediately.

**Example:** "The OG-image renderer can't draw the █ cursor — it renders a box glyph." Assumptions: (a) the cursor must be a *text character* — belief; (b) the default font is the only font — belief, the renderer accepts custom fonts; (c) the design needs a cursor at all — belief. Breaking (a) solves it in minutes: draw the cursor as an orange rectangle `<div>`, not a glyph. (Breaking (b) was the fix for the ✓ checkmark next to it — load a font that has one.)

## T2 — Inversion

**Fires on:** framing walls; any wall where forward motion has stalled.

**Moves:** Ask "how would I *guarantee* this stays blocked / fails completely?" List those answers earnestly — then negate each one. The negations are angles. (Jacobi via Munger: "Invert, always invert.")

**Example:** "Can't get replies to cold outreach." Guarantee zero replies: generic opener, ask for 30 minutes, no reason to reply this week, sent to the wrong person. Negations: hyper-specific opener referencing their work this week; ask for nothing (give something); find the person who *owns the pain*, not the title.

## T3 — First principles

**Fires on:** assumption walls, tool walls with deep inherited design.

**Moves:** Strip the problem to what physics/math/economics actually require. Ignore how it's currently done — that's an artifact of someone else's constraints. Rebuild the minimum path from requirements up. Ask: "if nobody had ever solved this before, and I had today's tools, what would I do?"

**Example:** "Shipping costs make this product unviable." First principles: what does the customer actually need to *receive*? If the value is information + a few grams of material, ship the file and license local production — the freight was an artifact of a pre-digital design.

## T4 — Altitude shift

**Fires on:** framing walls. Also the universal Step 2 restatement.

**Moves:** Restate the problem one level UP (what job is this step serving? could that job be done without this step?) and one level DOWN (what *literally* fails — which line, which field, which sentence?). Walls often exist at exactly one altitude.

**Example:** "The vendor's API has no bulk-export endpoint." Up: the job is *getting our data out monthly* — a scheduled per-record crawl also does that job. Down: the export button in their UI works fine — automate the button (browser automation) instead of the API.

## T5 — Work backwards from solved

**Fires on:** framing and assumption walls; anything where the path forward is foggy.

**Moves:** Assume it shipped. Write the one-paragraph changelog entry / press release dated 3 months out. Now ask: what MUST have been true for that to happen? Chain backwards from the solved state to today. The first link backwards from "solved" is often visible even when the first step forward isn't.

**Example:** "No idea how to get our first 100 users." Changelog from the future: "100 users, 60 from the launch partner's newsletter." Must-have-been-true: a launch partner with an audience who wins by sharing this. That's the actual task — find *that partner* — not "do marketing."

## T6 — Analogical transfer

**Fires on:** tool walls, gatekeeper walls, anything that feels unprecedented.

**Moves:** Name the problem's *structure*, stripped of domain ("limited slots, unpredictable demand," "gatekeeper controls distribution," "cargo must survive a hostile channel"). Ask: who has this structure in a totally different domain — restaurants, logistics, biology, military, dating apps? How do they solve it? Port the mechanism, not the surface.

**Example:** "Users abandon our 9-step onboarding." Structure: mandatory sequence with dropout. Who else: airport security (move the wait into parallel/idle time), video games (tutorial disguised as play). Angles: collect steps 4–9 lazily *during* first use; make step 1 deliver the aha before asking for anything.

## T7 — Constraint toggling

**Fires on:** resource walls.

**Moves:** Take the binding constraint and toggle it BOTH ways:
1. **Remove it:** "If money/time/headcount were free, what would I do?" — then ask what a 5% version of that answer costs.
2. **Tighten it 10x:** "If I had one hour / $100 / just myself, what would I do?" — brutal constraint forces the essential move to the surface.
Both directions expose which constraints are real and which are assumed comfort.

**Example:** "Can't afford a rebrand ($40k agency quote)." Free-money version: full agency process → its 5% core is one senior designer's taste applied to logo + type + 3 templates. 10x-tighter version ($4k): hire that one senior designer for a week. The agency was packaging, not the value.

## T8 — Provocation / random entry

**Fires on:** resource walls, staleness, sessions where the first 3 techniques produced variations of the same idea.

**Moves:** (de Bono) State a deliberately wrong/absurd version of the situation ("Po: customers pay us to see ads," "Po: the app has no interface") — then harvest the *movement*: what direction does the absurdity point? Alternative: random entry — pick an unrelated noun (open a book, point), force-connect it to the problem, harvest.

**Example:** "Newsletter growth is flat." Po: *readers write the newsletter.* Movement: reader-submitted teardowns as a recurring section → contributors share their own issue → each issue ships with built-in distribution.

## T9 — SCAMPER

**Fires on:** tool/tech walls — run it against the blocked component specifically.

**Moves:** (Eberle's mnemonic, built on Osborn's brainstorming checklist.) Against the component that "can't": **S**ubstitute (different primitive/library/channel), **C**ombine (merge with an adjacent step), **A**dapt (borrow a mechanism that works elsewhere in the system), **M**agnify/minify (what if this step were 10x bigger or disappeared?), **P**ut to other use (can an existing feature be abused into doing this?), **E**liminate (does this step need to exist?), **R**everse (flip the order/direction/actor).

**Example:** "The metadata route can't re-export another route's component" (Next.js twitter-image, 2026-07). Substitute: literal config exports + delegated default import — same dedupe, analyzable statically. Eliminate was also on the table: delete twitter-image entirely and let og:image serve both.

## T10 — Interrogate the no

**Fires on:** gatekeeper walls — a person or org said no.

**Moves:**
1. **Who exactly said no?** (A person? A policy? A support macro? The intern who answers email?) A "no" from someone without authority to say yes is routing information, not an answer.
2. **To what exactly?** Replay the ask — was it the thing you wanted, or a scary-sounding version of it?
3. **What's their incentive?** What does yes cost them (risk, effort, precedent)? Can you remove that cost?
4. **What would make it a yes?** Smaller ask, different framing, pilot instead of commitment, their win made explicit, a different door entirely (partnerships instead of sales, API instead of contract).
5. **Guardrail:** if they understood the ask and meant the no — that no is real. The move is finding a different door they'd *happily* open, never pushing the closed one.

**Example:** "The conference rejected our sponsorship." Who: the sponsorship coordinator, sold-out tier. To what: a booth. Incentive: floor space is zero-sum. Different door: the speaker dinner needs a host; the lanyard vendor fell through. Same visibility, no booth, cheaper — and the coordinator *wants* to say yes to solving their own problem.

---

## Anti-patterns

- **Costume angles** — 10 angles that are 3 ideas reworded. The quantity gate counts *kinds*.
- **Premature feasibility** — "that won't work because…" during generation kills the wild angle that would have seeded the viable one. Triage is Step 5, not Step 4.
- **Technique tourism** — running all 10 techniques shallowly beats nothing, but 3 techniques run hard beat all 10 run soft. Trust the triage.
- **Skipping the restatement** — techniques applied to a badly-stated problem produce well-organized answers to the wrong question.

SKILL.md 10.2 KB

---
name: unstuck
description: "When a solution seems impossible and the path forward is blocked — the antidote to any roadblock or wall. Refuses to take no for an answer: classifies what kind of \"no\" you actually hit, then runs targeted lateral-thinking techniques (assumption autopsy, inversion, first principles, constraint toggling, analogical transfer, and more from a 10-technique inventory) until the wall cracks or is proven load-bearing. Generates a minimum of 10 angles before evaluating any. AGENTS: use this on yourself mid-task — when an API doesn't support what you need, an approach has failed twice, or a \"that's not possible\" / \"the only option is\" sentence is forming in your response, run the fast path BEFORE reporting a dead end; every dead-end report should arrive with tried-angles receipts. Archives every wall to ~/.config/makerskills/unstuck/archive/ so you learn which techniques crack YOUR walls. Sits upstream of decide: turns \"impossible\" into 2–3 viable angles, then decide picks one. 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,\" \"think outside the box.\""
metadata:
  version: 0.1.0
---

# /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.
- `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.