Skip to main content
skill CX Codex

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

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add Yeachan-Heo/oh-my-claudecode --skill loft -a claude-code
Open on GitHub

What 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-code

2Manually: put the files in place

~/.claude/skills/loft/SKILL.md

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

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

Similar skills

All skills for Design →

From the same set48

The whole set →
architecture-survey architecture-survey inspects your module graph to spot shallow boundaries, false seams, and misplaced logic. Useful when changes start rippling across too many files at once. CX Codex +1 201installs agent-doc-discipline agent-doc-discipline sets writing rules for agent-facing specs, skills, and CLAUDE.md files. It ensures a fresh agent session acts correctly on instructions alone without needing prior chat context. CX Codex +1 196installs diagram This skill picks a compact visual for code structure, from a call tree to a Mermaid diagram. Use it when prose makes relationships hard to follow. CX Codex +1 194installs ask-navigator ask-navigator — a skill that turns an unclear effort into a map of decision tickets on the repo's issue tracker. It works the frontier one ticket per session until the route clears, then hands decisions over without building anything. CX Codex +1 191installs intent Turns a pasted chat or problem report into a reviewed intent.md. It gives /launch a decision brief instead of code. CX Codex +1 187installs pr pr — a Claude Code skill that drafts pull request descriptions from the session paper trail. It compiles verified test evidence, visual summaries, and rollback risks into a markdown body. CX Codex +1 161installs map This Claude Code skill routes a task to the matching skill in the collection. It maps work to a delivery stage or a specific workflow, but does not carry out the task itself. CX Codex +1 160installs refit refit is a Claude Code skill that reviews OMC runtime traces to find agent workflow friction and propose targeted fixes to checks, configs, and instructions. CX Codex +1 158installs

Project sponsors

Companies that keep this analytics open