Slash Commands: A Deep Dive

The Big Idea

Most people use Claude Code with two things: typing requests directly, and occasionally running /help. The book's analogy: "like buying a car and only ever driving straight — never discovering reverse, cruise control, or lane assist."

Why This Topic Matters

• The context window is finite; a multi-hour session pushes against the limit. How well you manage context decides whether you can finish complex tasks.
• Mistakes are not fatal if you know the rollback commands — you can work faster and more boldly.
• Without /cost and /model, you have no sense of what a session costs or how to spend less.

Category 1 — Context Management

/compact — smart compression, not deletion

Compresses conversation history into a distilled summary, freeing context space. The key word is smart: it uses AI to summarise — keeping key decisions, code-change records, and your stated preferences, discarding only redundant intermediate steps.

When to use it:

• After 20+ rounds — every exchange resends the full history, so the longer it gets, the more tokens you burn.
• When shifting task direction — Feature A → Feature B: compact away the A-specific noise.
• When Claude feels slower — longer context means slower responses; compacting speeds it up.

Advanced usage — tell it what to keep:

/compact Keep all architecture decisions and bug fix records; compress away the detailed code

/context — see where your tokens are going

Shows a detailed breakdown of the current context: system prompts, CLAUDE.md, Skills, and conversation history. Its value is visibility — when you suspect the context is nearly full, run it first to see what is consuming space (a large CLAUDE.md, too many MCP tools, or an overgrown history). You need the data to make the right call.

/clear — a clean slate

Wipes the entire conversation history and returns to the initial state — equivalent to closing and reopening claude, just faster. Recommendation: before an unrelated new task, always /clear first. Chaining Feature A and Feature B in one session leaves A's context taking up space; /clear is free and the tokens it saves are real.

Category 2 — Safety Nets

/rewind — surgical-precision rollback

Press Esc twice or type /rewind. Three options:

"Rewind code but keep conversation" is the most powerful. If Claude modified 10 files and the direction was wrong, restore the files but keep the discussion. You can then say: "That approach didn't work. Let's try a different angle; this time only touch the 3 core files." Claude still knows what you discussed and why the first attempt failed, so the second attempt is usually much better.

/fork — parallel-universe exploration

Branches the current conversation into a new independent thread. Both branches share the prior history but develop independently from that point.

You: Help me design a user authentication system
Claude: Option A is JWT stateless authentication...
You: /fork
(New branch begins)
You: Let's set aside the JWT approach. What about Session + Redis?
Claude: Option B is session-based authentication...
(Both branches run in parallel; compare and pick the better fit)

There is no cost to "going down the wrong path" — explore multiple directions at once and choose the best at the end.

Category 3 — Efficiency Tools

/cost — how much have you spent

Shows token consumption and approximate cost for the current session. The book says it "changed how I use Claude Code": a long session might run $2–5, a large refactor $10+. The point is not to be frugal — it is to consciously decide whether a task is worth that many tokens. Check it before a large task, when a conversation feels too long, and at the end of the day.

/model — switch models on the fly

/model sonnet   <- everyday tasks (fast and cheap)
/model opus     <- complex architecture decisions, large-scale refactoring

Sonnet costs roughly 1/5 of Opus, and for most coding — CRUD, simple bug fixes, boilerplate — it is more than sufficient. Switch to Opus only for problems requiring deep reasoning.

/fast — toggle fast mode

Uses the same model but produces output more quickly. If you don't need deep thinking and just want a well-defined task done fast, fast mode gives a noticeable speed boost.

/btw — a side question without breaking the flow

(Claude is refactoring your code...)
/btw What's the difference between readonly and const in TypeScript?
(Claude answers quickly, then continues refactoring)

Key detail: /btw responses don't enter the conversation history. They are one-time — they don't pollute context or consume extra tokens. Perfect for sudden small questions mid-task.

Category 4 — Project Management / Memory

Category 5 — Code Quality

/review — automated code review

After a set of changes, type /review and Claude audits all uncommitted modifications and suggests improvements — "a 24/7 code reviewer on call." It checks for:

• Potential bugs (null checks, boundary conditions)
• Performance issues (unnecessary loops, large data-set operations)
• Security problems (SQL injection, XSS, hardcoded secrets)
• Code style (naming consistency, file organization)

/simplify — three-angle code refinement

Launches three parallel agents that each review your changes from a different angle — reusability, quality, efficiency — then consolidates the findings and auto-applies the fixes. It directly modifies your code; when done, you review the diff and confirm.

Category 6 — Advanced Operations

Command Combinations: Workflow Patterns

Pattern 1 — Long Session Management

1. /clear          <- clean starting point
2. Complete Phase 1
3. /compact        <- compress Phase 1 details
4. Complete Phase 2
5. /compact        <- compress again
6. Complete Phase 3
7. /cost           <- check total consumption

Extends a 30–60 minute session into several hours while keeping Claude's understanding of the project intact.

Pattern 2 — Exploratory Development

1. Discuss requirements, align on direction
2. /fork           <- Branch A: Approach One
3. (Implement Approach One in Branch A)
4. Return to original branch
5. /fork           <- Branch B: Approach Two
6. (Implement Approach Two in Branch B)
7. Compare both results, choose the better one

Pattern 3 — Safe Refactoring

1. /review         <- audit current code state first
2. Have Claude begin refactoring
3. If direction is wrong -> press Esc twice -> /rewind to roll back code
4. Refactoring complete -> /simplify  <- three-angle refinement
5. /review         <- final audit
6. git commit

Pattern 4 — Economy Mode

1. /model sonnet   <- cheaper model for everyday tasks
2. Hit a complex problem -> /model opus  <- switch to the stronger model
3. Problem solved -> /model sonnet  <- switch back
4. /cost           <- see how much you saved

Visual Mental Model: Commands as Systems

CONTEXT MANAGEMENT      /compact  +  /context  +  /clear
SAFE EXPLORATION        /fork     +  /rewind
COST CONTROL            /cost     +  /model    (+ /fast)
PROJECT MEMORY          /init     +  /memory   +  /permissions
CODE QUALITY            /review   +  /simplify
HEALTH / SETUP          /doctor   +  /terminal-setup  +  /vim  +  /export

Important Comparisons

Common Beginner Mistakes

• Only ever using /help and /clear — ignoring the rest.
• Waiting until context is full to /compact, instead of compacting per milestone.
• Chaining unrelated tasks in one session without /clear.
• Guessing what's eating context instead of running /context.
• Fearing wrong turns instead of using /fork to explore freely.
• Never checking /cost, so a task's price is invisible.
• Running everything on Opus when Sonnet handles most coding at ~1/5 the cost.
• Interrupting a working Claude with a side question instead of /btw.
• Trusting /init's output as final rather than a starting point.
• Debugging Claude when /doctor would show an environment problem.

Best Practices

• Compact per milestone; pass instructions to /compact about what to keep.
• /clear before every unrelated task — it's free.
• Run /context before assuming what's full.
• Use /fork to compare approaches instead of committing early.
• Prefer "rewind code, keep conversation" so Claude remembers why attempt one failed.
• Check /cost before big tasks, on long sessions, and end of day.
• Default to Sonnet, switch to Opus only for deep reasoning, then switch back.
• Use /btw for stray questions.
• /init then edit; audit /memory periodically.
• Beginners: default permissions, open up high-frequency ops over time.
• /review before and after a refactor; /simplify to apply fixes.
• /doctor first when something inexplicable breaks.
• Combine commands into the four workflow patterns.

Slash Commands: A Deep Dive
│
├── Context          /compact (smart, per-milestone, can be instructed)
│                     /context (what's eating space)  /clear (full reset)
├── Safety nets      /rewind (conversation | code | both; "code-only" is best)
│                     /fork (parallel approaches, no cost to wrong paths)
├── Efficiency       /cost (know the price)  /model sonnet<->opus (~1/5 cost)
│                     /fast (same model, faster)  /btw (one-time, no history)
├── Memory           /init (draft CLAUDE.md)  /memory (audit files)
│                     /permissions (pre-authorize / restrict)
├── Quality          /review (suggestions)  /simplify (3 agents, auto-apply)
├── Advanced         /doctor  /vim  /terminal-setup  /export
│
└── Patterns
    1 Long session:  /clear -> phase -> /compact -> ... -> /cost
    2 Exploratory:   discuss -> /fork A -> /fork B -> compare
    3 Safe refactor: /review -> refactor -> (/rewind) -> /simplify -> /review -> commit
    4 Economy:       /model sonnet -> /model opus (hard bit) -> sonnet -> /cost