17 skills. First Build course.
Every command. Full reference.

At the very start of any new app, feature, or change — before a single line of code.

Reads .contextkit/seed.json (the 4-question install interview) and any existing CLAUDE.md/AGENTS.md first. Asks clarifying questions in rounds of 3-4 multiple-choice options — never one at a time, never a wall of ten. Keeps going until the goal can be stated back with no gaps. Writes CLAUDE.md (human-readable source of truth), a Codex AGENTS.md summary, and journey.json (the machine-readable roadmap the session HUD reads). No code is touched until you approve the plan.

Your very first session after installing. Run once.

Act 1: runs doctor with a cascade flag so engine checks light up one at a time — any red stops the tour and offers contextkit doctor --fix. Act 2: offers to wire the four starter MCP tools (exa, context7, gemini, crawl4ai) with one pick, proves each one works. Act 3: reads seed.json and confirms it in one line without re-asking. Act 4: fires the clarity lock on a real prompt live so you watch it work, then reveals the statusline cockpit and offers contextkit watch in a second pane.

After /start produces an approved plan. Repeat after each working piece.

Reads CLAUDE.md and journey.json, marks the next step in-progress before building. Uses the laziest-first reuse ladder: skip speculative work, reuse existing code, use the standard library, use a native platform feature, reuse an existing dependency — only then write new code. Marks the step done, saves lastSession.note (shown at the next session's open), and hands off to /check. Never claims it works itself.

After /step. Any time 'should work' appears.

Actually runs or opens the change and reports what it saw — the real user action (submit the form, click the button), real output. Checks edges beyond the happy path. Reports concrete evidence. If broken, hands to /fix rather than patching here.

Something is broken. An error message appeared.

Reproduces the bug on purpose first. Traces back to where it actually goes wrong, not where it first shows up. States the cause in one plain sentence, then makes one targeted change. 3-strikes rule: after three real attempts, stops and questions the approach instead of piling on more patches.

Before accepting any diff. Before merging or committing a batch of work.

Reads the actual diff (not a summary) against the original goal in CLAUDE.md. Scans for secrets/keys in every changed file, half-done paths, sneaked scope, real bugs. Splits into must-fix and later. Never rubber-stamps.

Code looks over-built. Forty files for a two-line change. New dependency for a one-liner.

Works the reuse ladder in reverse: cuts speculative abstractions, one-use interfaces, dependencies doing what native features or a few lines would, fifty lines where one would do. Reads end-to-end first — the smallest change in the wrong place is a second bug. Re-checks it still works after cutting. Never cuts input validation, error handling, security, or accessibility.

Ready to deploy. First time going public.

Runs /secrets first — never skipped. Commits and pushes to GitHub. Connects to Vercel or Netlify, sets production env vars (the #1 reason deploys work locally but break live), deploys, then opens the live URL and tests it. Runs the celebrate script once the URL returns 200. Deploy and working are two different things — this confirms both.

Before anything goes public or gets deployed. Mandatory before /ship.

Greps source for key shapes: sk-, AKIA, AIza, ghp_, xox, -----BEGIN, password =, secret =. Checks git history, not just current files — a deleted key is still leaked. Verifies .env is gitignored and was never committed. Confirms no secrets in frontend/client code. Checks for unhashed passwords and wide-open routes. If a key was ever public: rotate it. Deletion is not enough.

Something broke badly. Work seems lost. Git is scary.

Stops you making it worse first. Shows git status + log + reflog in plain English. Picks the gentlest fix: restore/stash before reset, revert before reset --hard, reflog before 'work is lost'. Explains exactly what any destructive operation will delete and gets an explicit yes. Lands on a working state then checkpoints it.

After the AI wrote something you can't read. Before a code review.

Reads the actual code (not the filename). Gives the shape in 2-3 sentences: what it does, how pieces fit, what calls what. Points at the few lines that do the real work and anything risky. Never narrates line-by-line. Uses one analogy if it makes it click. Checks it landed and invites the next question.

Before building any UI. Before the first screen. If there's no DESIGN.md yet.

Asks 2-3 real questions per round — not confirmation questions. Round 1: what it is and who it's for, brand vs product surface. Round 2: three personality words, named references and anti-references (what it must NOT feel like — the most useful answer you can give). Round 3: color strategy, typeface direction (rejects Inter/Geist/Roboto by default), motion energy. Writes DESIGN.md: your design source of truth including a Creative North Star, named anti-references, and token rules. Never designs from the prompt alone.

After building any screen. Before calling design done.

Looks at the actual rendered screenshot, not the code, at three widths (390/768/1440). Pulls intent from DESIGN.md. Runs detect-slop.mjs for measurable tells (P1 exits 1), then does a holistic pass: squint test for hierarchy, contrast ≥4.5:1, spacing rhythm. Scores 0-40 honestly — most real UIs land 20-32. Tags each issue P0-P3. Lists the top 3 highest-impact fixes. Reports only. Editing is /polish.

After /design-check finds issues. Any time output looks AI-made.

Reads DESIGN.md first — refuses to polish without a design system, runs /design-intake instead. Classifies each issue: missing token (add to DESIGN.md, then use it) / one-off deviation (snap to existing token) / conceptual misalignment (rework toward the North Star). Runs detect-slop.mjs and works the full list: swap reflex fonts, kill gradient text, drop violet decorative gradients, fix contrast, put spacing on a 4pt scale, cut em-dashes from copy. Re-runs until 0 P1 tells remain and rescores.

The agent is guessing from stale training data. You need live web search, current library docs, or a real browser.

Asks what you actually need before adding anything (Rule 0). The starter four: exa (web search + docs, needs a free EXA_API_KEY), context7 (current library docs piped into the agent, no key), gemini (vision — lets the agent check screenshots and designs, needs a Gemini key), crawl4ai (reads a specific site into clean text, no key). Adds the right JSON block to .mcp.json for Claude Code, Codex, or Antigravity. Proves each one works with a real call before moving on. Never adds servers 'just in case'.

Something feels clunky. You're doing manually what Claude Code has a built-in for.

Matches one feature to your actual pain: re-explaining the project every session (CLAUDE.md), lost context (/clear, /compact), it ran off and built the wrong thing (Shift+Tab plan mode), repeating the same workflow (custom skill in .claude/skills/), visual bug (paste screenshot), same rule every time (hook in settings.json). Recommends the one that fixes your problem, not a product manual. Full list in reference/claude-code-cheatsheet.md.

Something in Codex feels clunky. You're repeating yourself across tasks.

Same philosophy as /claude-tips but Codex-specific: re-explaining rules (AGENTS.md in the repo or ~/.codex/AGENTS.md), wanting a plan before edits (Plan mode), repeating a workflow (SKILL.md in .agents/skills/), needing a check every time (.codex/hooks.json), needing current docs or a browser (MCP). Gives the five must-knows: AGENTS.md, Plan mode, skills, MCP, and hooks. Points to /help, /hooks, /mcp for exact interface since Codex updates often.

When you want the agent to explain what it does and why as it goes.

Switches output to a teaching tone. After each meaningful code change, a short card appears: WHAT IT DOES in your own words, WHY THIS WAY (the choice made and the road not taken). Teach-once aware — checks .contextkit/concepts.json and never cards the same concept twice. Holds a 10-minute cooldown and skips trivial edits. Toggle: contextkit cards on, or /config > Output style.

When you want a warmer, more conversational tone without losing directness.

A softer register that still leads with the point, recommends rather than lists options, and pushes back when needed. Direct stays the default. Switch via /config > Output style. Switching back to direct is always one command.