loft — Claude Code skill: what it does, how to install
loft resolves deadlocked design and logic questions by building disposable runnable prototypes that never merge into main.
MIT 189 installs ★ 40,997 updated 2026-10-24
npx skills add Yeachan-Heo/oh-my-claudecode --skill loft -a claude-codeWhat loft does
Loft borrows a shipbuilder practice: verify hull lines full scale before cutting steel. When discussion stalls around phrases like "we need to see it first", the skill directs the agent to generate an isolated, runnable prototype on a separate loft/<name> branch. You react to the result, record the choice in an issue or spec, and leave the scratch code on that branch.
Two pathways structure the build. For state, reducers, or core algorithms, the agent isolates a pure logic module with no DOM or framework dependencies and wraps it in a clickable HTML shell with scenario buttons. For visual layout, it creates a single route with three structurally distinct variants and an in-page toggle. Tests, database storage, and error handling are excluded so the build takes minutes.
The artifact is strictly disposable: attempting to expand this throwaway code into production modules defeats the skill's guard against sunk cost.
What it helps with
- test state machine edge cases inside an interactive HTML shell
- compare three structural UI variants behind a single route switcher
- settle spec disputes when written arguments fail to convince
- capture an architecture decision without polluting the main branch
Example prompts for the agent
- Build a standalone HTML shell to click through tricky discount calculation edge cases
- Prepare three structural layout variants for the dashboard navigation on a single route
- Create a quick throwaway prototype for the checkout state machine under loft/checkout-flow
How to install loft
1Skills CLI (Vercel)
npx skills add Yeachan-Heo/oh-my-claudecode --skill loft -a claude-code2Manually: put the files in place
~/.claude/skills/loft/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/loft/
1Skills CLI (Vercel)
npx skills add Yeachan-Heo/oh-my-claudecode --skill loft -a codex2Manually: put the files in place
.agents/skills/loft/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add Yeachan-Heo/oh-my-claudecode --skill loft -a cursor2Manually: put the files in place
.cursor/skills/loft/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install Yeachan-Heo/oh-my-claudecode skills/loft2Manually: put the files in place
.github/skills/loft/SKILL.md1Skills CLI (Vercel)
npx skills add Yeachan-Heo/oh-my-claudecode --skill loft -a gemini-cli2Platform CLI
gemini skills install https://github.com/Yeachan-Heo/oh-my-claudecode --path skills/loftManually: put the files in place
.devin/skills/loft/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add Yeachan-Heo/oh-my-claudecode --skill loft -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about loft
How do I install loft in Claude Code?
Run npx skills add Yeachan-Heo/oh-my-claudecode --skill loft -a claude-code. The skill file will be placed at ~/.claude/skills/loft/SKILL.md.
What does the loft skill do?
It builds a temporary, runnable prototype on a dedicated loft/<name> branch to settle contested UI or state choices. Once the choice is made, the artifact stays behind on the branch and never merges to main.
When should loft not be used?
Skip loft when facing software bugs, unsettled project goals, or questions already settled by repository evidence and existing architectural decision records.
Source text
SKILL.md · MIT
---
name: loft
description: 'Loft the shape before cutting steel — answer a design question that prose cannot settle by building a throwaway artifact: a pure logic module in a clickable shell, or structurally different UI variants behind one route. The captain reacts to the artifact; the answer folds into the decision; the artifact never docks. Use when a design question stalls in words, when a navigator map carries a loft ticket, or when a spec discussion reaches "we would have to see it".'
level: 3
---
# Loft
**Cut no steel until the shape is fair.** Shipwrights loft the hull's lines full-scale and fair them before a single plate is cut. Loft applies the same order to design questions: when words have run out — two plausible answers, neither falsifiable by talk — build a cheap runnable artifact, let the captain react to it, and fold that reaction into the decision.
**The role contract.** The crew builds the artifact; the captain's only job is to react — and that reaction **is** the decision. The artifact is an instrument for seeing, never a head start on the deliverable.
## When to loft
- a design question stalls in prose: repeatedly rephrased, still not settleable ("how should the path page look", "does this state model feel right")
- a navigator map carries a `loft` ticket
- a spec discussion reaches "we would have to see it first"
Do **not** loft when:
- the question is answerable from repo evidence or by asking the captain (that is interviewing, not lofting)
- the destination itself is unclear (that is fog — `/oh-my-claudecode:ask-navigator`)
- the answer already lives in an ADR (do not re-loft settled decisions)
- the "design question" is actually a bug (that is the debugger's jurisdiction)
## Choose the fork
Pick by what the question is asking. A wrong fork wastes the whole artifact.
### Logic fork — is the model right?
For questions about state, business rules, data shape, or algorithms ("does unlocking regress on a retake?", "does this reducer hold at the edges?"):
1. Isolate the decision-bearing core — the state machine, reducer, schema, or algorithm — as a **pure module**: no DOM, no I/O, no framework. Written so that, once the shape is confirmed, it moves into the real codebase unchanged.
2. Wrap it in a single clickable HTML shell: one button per scenario, the tricky edge cases walked through in order, full state visible after every click.
3. On confirmation the module is ready to lift — it re-enters as real work through launch. During the loft itself `main` stays untouched and the shell stays behind on the branch.
### UI fork — what should it look like?
For questions of shape and arrangement ("steps or cards?", "where does progress live?"):
1. One route, **three variants that differ in structure** — information architecture, navigation model, density. Variants that differ only in styling answer nothing: three reskins are wallpaper.
2. A switcher on the page cycles the variants; embed into the existing product where possible, so real data density stresses the design instead of three tidy fake rows.
3. On confirmation, the **decision** transfers and the variants stay behind on the branch as the record of why it looks this way.
## The discipline
- One command to run — the repo's simplest existing serve command; inline the module into the shell if `file://` module CORS would bite. Loads in seconds; no build step beyond what the repo already has.
- No persistence, no tests, no abstractions, no error handling beyond the happy path. The artifact should be something you **would not want to ship** — the rules exist to keep it that way.
- Expect the first shape to be argued with: revise on the branch within the same session. The captain confirming the **final** shape is the decision; an artifact nobody argues with usually answered a question nobody had.
- The artifact's whole life is minutes to build and one session to decide. If it starts growing into production code, stop: that work is a launch effort, not a loft. Sunk cost is the failure mode this skill exists to prevent.
- One loft answers **one** question. Two questions are two lofts — or one question that was actually two.
## Fold the answer
The artifact is evidence, not a landing. When the captain reacts:
1. Record the decision where it lives — the issue comment, the spec's Implementation Decisions, or the pending-decision note — in the captain's own words plus one line of why. A fragment more precise than prose (the reducer, the state machine, the schema) may be inlined there, marked as lofted.
2. Push the artifact to a `loft/<name>` branch. It never merges: it stays as the primary source a future reader can open when the decision's "why" matters.
3. Nothing from the artifact lands in `main` — for the logic fork the confirmed module re-enters as real work through launch, for the UI fork the real page is built fresh from the decision.
## Scope and non-goals
- Loft produces **answers, not deliverables**: no runtime, no state files, nothing always-on.
- It does not diagnose (debugger), does not chart fog (`/oh-my-claudecode:ask-navigator`), does not approve its own answer (the captain's reaction is the only acceptance).
- It does not replace seam approval: a lofted UI shows the shape; the test seams for it are still approved at C2.
## Completion definition
The captain reacted, the answer sits where the decision lives, the artifact sits on its branch — and no line of the artifact is in `main`.
© Yeachan-Heo · MIT · Yeachan-Heo/oh-my-claudecode