Greenfield to shipped

The full chain when you're starting a new product from scratch — from rough idea to a shipped pull request. Names the bassclef skill for each stage.

Use this when

You have a rough product idea. Not a spec. Not a mock. Just a sentence or two of what you want to build, or a customer pain you need to solve.

You want to know the exact chain of bassclef skills to run in order, so you can go from idea to shipped code without guessing which discipline fits which stage.

Skip this when

You already have a chosen mock or a written spec. Head straight to the tightest three — /riff → /launch → /build. Those three take you from a picked design to a merged PR.

Also skip if you are fixing a bug or making a one-line change. Use quick-fix or auto-fix instead.

The chain — six stages, one skill per stage

The chain runs top to bottom. Each stage produces the input the next stage needs. Stop after any stage if the output is enough for what you are building.

Stage 1 — Discover

Job: turn a rough idea into a clear picture of who wants what and why.

Skills to run:

/interview-me — bassclef interviews you. 30 or 90 minutes. Produces a filled 3-box lean canvas plus candidate jobs-to-be-done.
/empathy-map — Dave Gray's 7-section map for one persona. Goal, See, Say, Do, Hear, Think and Feel, Pains, Gains.

When to use each: run /interview-me when the customer is you or someone you can access. Run /empathy-map when you have interview transcripts or research notes to structure per persona.

Output: a docs/personas/<name>.md file with the persona shape plus a docs/canvases/<slug>-lean-canvas.md file with the 3-box frame.

Stage 2 — Frame the problem

Job: name the customer, the problem, and the unfair advantage. Turn the discovery output into a one-page business shape.

Skills to run:

/lean-canvas — Ash Maurya's 9-box canvas filled through persona lenses. Two modes: commercial (revenue in dollars) or growth-loop (audience plus credibility).
/value-prop-canvas — Strategyzer's Value Proposition Canvas. Maps customer jobs, pains, and gains to product features.
/jtbd-tasks — turns each job-to-be-done into a task hierarchy (HTA tree) plus decision points (CTA).
/personas — write or edit the personas file that every downstream skill reads.

When to use each: /lean-canvas names the business. /value-prop-canvas sharpens the product-market fit. /jtbd-tasks decomposes the customer job into tasks a design can serve.

Output: a lean canvas, a value prop canvas, a JTBD task tree, and a personas file.

Stage 3 — Sketch

Job: turn the frame into two or three clickable HTML mocks so you can pick a direction before writing code.

Skills to run:

/riff — produces 2-3 clickable mock alternatives for a UI surface. Each mock uses a different luminary lens. One picks a marketing variant. Another picks a build direction.
/stage — deploys the mocks to a live URL so you can walk them on any device.

Output: mocks at docs/prototypes/<slug>/variant-{a,b,c}/, a gallery page, and a preview URL you can share.

Stage 4 — Design

Job: turn the chosen mock into information architecture, interaction flows, and a code decomposition.

Skills to run:

/ia-model — the information architecture for the surface. Where content lives, how the reader navigates.
/interaction-design — the interaction flows. What happens when the user clicks.
/decompose — the code decomposition. Which classes take which responsibilities.

Output: IA model, interaction diagrams, and a decomposition file at docs/decompositions/<slug>.md.

Stage 5 — Plan

Job: turn the design into a buildable spec plus user stories.

Skills to run:

/launch — the porcelain command that chains /interpret-input + /spec + /use-case + /user-stories. Produces a spec, INVEST-shaped user stories, and a migration plan.

Output: a spec at docs/specs/<slug>.md, INVEST user stories, and a migration plan.

Stage 6 — Build and ship

Job: turn the plan into a merged pull request.

Skills to run:

/build — dispatches Builder per user story. Runs /verify per commit. Runs Reviewer against the spec. Opens a PR.
/verify — post-build check per change type. Blocks commit if the check fails.
/deploy-prod — production deployment procedure. Test, build, push, CI, verify.

Output: a merged pull request with code, tests, spec traceability, and a Reviewer sign-off record.

Discover what fits your work

Two skills help when you know the goal but not the exact chain:

/howdoi — search bassclef skills and rules for an adopter goal. One question in. A short list of skills that match your goal.
/extract-intent — takes text and returns matched luminaries with confidence scores. Useful when the design lens for your surface is not obvious.

The chain, at a glance

Discover  → /interview-me, /empathy-map
Frame     → /lean-canvas, /value-prop-canvas, /jtbd-tasks, /personas
Sketch    → /riff, /stage
Design    → /ia-model, /interaction-design, /decompose
Plan      → /launch
Build     → /build, /verify, /deploy-prod

When to skip stages

The chain assumes a fully greenfield product. You can start partway in if you already have the input:

Have personas and a validated problem? Start at Stage 3 (Sketch).
Have a chosen mock? Start at Stage 4 (Design) or Stage 5 (Plan).
Have a written spec? Jump to /build — the tightest-three quickstart walks this path in 15 minutes.

Stopping partway is also fine. A /lean-canvas alone tells you if the business shape holds. Two /riff mocks alone can settle a design debate. You do not have to run every stage.

What to try next

Run /interview-me with a 30-minute time budget to test the discovery stage on a real idea.
Read the tightest-three deep dive for the design thinking behind /riff → /launch → /build.
Read the workhorses page for the skills you will run every session (/verify, /temperance, /kiss).

Greenfield to shipped

On this page