Skills Overview

Michi’s skills are Claude Code slash commands that guide different phases of development. They range from rigid (follow every step) to flexible (a posture, not a checklist).

The core loop

Most milestone work follows a three-skill cycle:

/michi-planning → /michi-session → /michi-debrief

Plan the work, execute it with verification discipline, review what happened. This is the load-bearing structure. Bootstrap happens once before the first cycle. Everything else supports or supplements this loop.

All the skills

Skill	Type	When to use
michi-bootstrap	Flexible	Before first session — onboard a project, scaffold docs
michi-explore	Flexible	Research, brainstorming, cold starts, pre-planning
michi-planning	Flexible	Before implementation — write the milestone plan
michi-session	Rigid	During implementation — execute with verification
michi-debrief	Flexible	After implementation — review, capture, calibrate
michi-sustainability	Flexible	Between milestones — health checks at scaled depth
michi-scenario-test-builder	Flexible	During planning — generate Kaner-style scenarios
michi-workshop	Flexible	Everyday work — bug fixes, small features, quick tasks
michi-expedition	Flexible	Learning-mode work — open-ended exploration where the end isn’t known
michi-loop	Rigid	Autonomous loops — gate, contract, verifier, stop conditions, lights-off launch
michi-away	Flexible	Stepping away mid-work — keep the cycle running Entrusted; guesses and blocks logged for your return
michi-second-look	Rigid	Independent review from a separate session — delivered work against the accepted criteria, read-only; audit mode asks what should change
michi-pr-prep	Flexible	Before PR review — prepare a review guide
michi-docs	Flexible	At handoff — reader-facing project docs, or a standalone handoff, derived from the working docs
michi-docs-site	Flexible	Docs infrastructure — an internal docs browser or a PDF build recipe

Only michi-session, michi-loop and michi-second-look are rigid. The rest adapt to the situation.

The lanes

The core loop is the production lane — convergent work marching toward a known deliverable. Two other lanes exist, and the form of verification you can answer routes between them:

• Convergent (“how do I know I’m done?”) → the production lane. When done-criteria are measurable, a trustworthy verifier exists, and autonomy has been earned, michi-loop can run the work lights-off.
• Progress (“am I making progress, or spinning?”) → michi-expedition, the learning-mode lane — spiral toward clarity, accreting a portrait instead of shipping a deliverable.

Skill flow

michi-bootstrap (once)
  └── Creates: Michi doc structure, CLAUDE.md, PROJECT.md, STATUS.md

michi-explore (as needed)
  └── Produces: research findings, epic docs, shared understanding

michi-planning
  ├── Explores codebase, surfaces assumptions
  ├── Co-designs verification scenarios
  └── Produces: milestone plan doc

michi-session
  ├── Executes against the plan
  ├── Logs decisions, notes, discussion items
  └── Produces: committed milestone, verified code

michi-debrief
  ├── Reviews decisions and discussion items
  ├── Promotes learnings to journal, patterns, CLAUDE.md
  └── Produces: journal entry, trust assessment

michi-sustainability (between milestones/epics)
  └── Assesses: code quality, test quality, architecture, knowledge gaps

Skill transitions

Skills aren’t silos — work flows between them naturally.

Workshop → full lifecycle. In one project, a session started with /michi-workshop to investigate a Python export tool. The question “should it move to JS and add tests?” grew the scope. The human initiated a transition: workshop → bootstrap → planning → session → debrief. The workshop skill’s guidance says “know when you’ve outgrown it” — this was that moment.

Explore → planning. Research often precedes planning. /michi-explore builds the shared context that makes a plan grounded rather than speculative. When the exploration produces enough to plan against, transition to /michi-planning.

Planning → session. When the plan is reviewed and approved, /michi-session executes it. The plan doc is the handoff artifact.

Debrief → next planning. The debrief’s trust assessment, captured learnings, and updated scenarios feed directly into the next milestone’s planning. This is the spiral — each debrief makes the next plan better.

Choosing the right skill

• Quick task, minimal ceremony? → michi-workshop
• Need to understand something first? → michi-explore
• Ready to build a milestone? → michi-planning → michi-session → michi-debrief
• Between milestones, want a health check? → michi-sustainability
• Need verification scenarios? → michi-scenario-test-builder (during planning)
• Preparing a PR for review? → michi-pr-prep
• Open-ended discovery, no known deliverable? → michi-expedition
• Convergent work with a verifier you trust, run unattended? → michi-loop
• Stepping away, want the work to keep moving? → michi-away
• Want delivered work checked by an agent that wasn’t there? → michi-second-look, from a separate session
• Handing work to someone who wasn’t in the sessions? → michi-docs
• Want to browse your project docs as a site? → michi-docs-site

Individual skill details are in the Skills Reference.