Claude Code Cheat Sheet: The Slash Commands

Every built-in slash command in Claude Code, organized by situation - with recommendations on which ones to use every day.

Most people using Claude Code don't know half the commands available to them. Not because they're hard to find - type / and the list appears. But because the list is long, unorganized, and gives you no signal about what matters.

This is the reference I wish existed when I started. Every built-in slash command, organized by when you actually reach for it - with my honest take on which ones you need to use every single session.

Before You Touch Anything: `/init`

If there is one command that separates people who fight Claude from people who ship with it, it's /init.

Run it once when you start a new project. Claude interviews you about the codebase, your stack, how you work, what it should never touch - and writes all of that into a CLAUDE.md file in your project root. That file loads automatically at the start of every session.

Without it, Claude starts from scratch every time. With it, Claude walks into the project like a senior developer who already read the README.

Five minutes of setup. The payoff is every session after that.

Commands You Should Use Every Day

These are not optional. Build them into your muscle memory.

Starting a session:

/resume - picks up exactly where you left off. Never start a session cold when you can continue a saved one.
/context - shows how full your context window is. Check this before starting heavy work so you don't hit the wall mid-task.
/model - confirms which model you're on. Matters more than most people think.

While building:

/plan - makes Claude map the approach before touching any files. This is the architect move. Think before you build.
/compact - compresses conversation history when the session gets long. Frees up context without losing your thread.
/diff - shows all uncommitted changes in an interactive viewer. Use this before every commit, not after.

Before shipping:

/security-review - scans your pending changes for vulnerabilities. Injection issues, auth gaps, data exposure. Run it before every merge.
/review - full PR review in your current session.

When something breaks:

/doctor - full health check of your Claude Code installation. Press f and Claude fixes what it finds.
/rewind - rolls back the conversation and code changes to a previous checkpoint. The undo button you actually want.

The Commands Worth Knowing

These aren't daily drivers, but you'll reach for them.

/background - detaches the current session to run as a background agent. Your terminal is free while Claude keeps working. Check progress with /tasks.

/batch - orchestrates large-scale changes across a codebase in parallel. Claude breaks the work into independent units, one sub-agent per unit. For serious refactors across many files.

/branch - forks the current conversation. The original is preserved. Use this when you want to try a risky approach without committing to it.

/effort [low/medium/high/max] - controls how hard Claude thinks before responding. Default is fine for most things. Crank it to high for architecture decisions.

/memory - opens and edits your CLAUDE.md files directly. Also manages auto-memory (things Claude learned on its own). Think of this as the agent's long-term brain.

/fewer-permission-prompts - scans your session transcripts and adds common read-only operations to the allowlist. Stops Claude from asking permission for things it does every session.

The Full Reference

Everything below is the complete command reference for Claude Code, organized by situation. Copy it, save it, share it.

Ready to use - copy this

# Claude Code - Built-In Commands Reference
### AI Architects Lab | May 2026 | Rani Ifrah

> This guide covers every built-in slash command in Claude Code.
> These are hardcoded into the tool - not skills or custom workflows.
> Organized by **situation**, not alphabetically - because architects think in context, not dictionaries.

---

## How Commands Work

Type `/` in the Claude Code prompt to see available commands. Built-in commands are always there. Skills (custom workflows) also appear in the same list.

**Rule of thumb:** If you didn't create it and it's not in your `~/.claude/` folder - it's built-in.

---

## 1. Starting a New Project

| Command | What it does |
|---|---|
| `/init` | Creates a `CLAUDE.md` file in your project - this is how you give Claude permanent memory about your project. Run this on every new project before writing a single line. |
| `/memory` | Opens and edits your `CLAUDE.md` memory files. Also manages auto-memory (things Claude learns automatically). Think of this as the agent's long-term brain. |
| `/permissions` | Controls what tools Claude is allowed to use without asking - file editing, bash commands, MCP calls. Use this to reduce friction or tighten security. |
| `/mcp` | Connects Claude to external tools via MCP servers (APIs, databases, Slack, etc.). This is how the agent gets "hands" beyond your local machine. |
| `/agents` | Define and manage background sub-agents for your project. Used for parallel work and complex orchestration. |
| `/hooks` | View and configure hooks - scripts that run automatically before or after Claude does something (e.g., run tests after every file edit). |

---

## 2. During a Work Session

### Controlling the Model

| Command | What it does |
|---|---|
| `/model` | Switch the AI model mid-session. Claude Sonnet, Opus, Haiku - each has different speed/cost/intelligence tradeoffs. Changing model clears the cache. |
| `/effort [low/medium/high/xhigh/max]` | How hard Claude thinks before responding. `low` = fast, cheap. `max` = slow, expensive, deeply reasoned. Default is usually fine - crank it up for architecture decisions. |
| `/fast` | Toggle fast mode on/off. Optimizes for speed. Use when you're doing repetitive, simple tasks and don't need deep reasoning. |

### Managing Context

| Command | What it does |
|---|---|
| `/context` | Shows a visual map of how full your context window is. Includes warnings when you're running low. Pass `/context all` for a full breakdown per item. |
| `/compact [instructions]` | Compresses the conversation history into a summary, freeing up context space. You can add instructions to guide what gets kept. Use this when sessions get long. |
| `/clear` | Starts a completely fresh conversation. Previous session is saved and accessible via `/resume`. Aliases: `/reset`, `/new` |
| `/btw <question>` | Ask a quick side question without adding it to your main conversation thread. Keeps the context lean. |

### Planning Before Building

| Command | What it does |
|---|---|
| `/plan [description]` | Enters plan mode. Claude maps out the approach before touching any files. This is the architect move - think before you build. |
| `/goal [condition]` | Sets a completion condition. Claude keeps working across multiple turns until the goal is met. Use for longer autonomous runs. |
| `/ultraplan <prompt>` | Drafts a full plan in a cloud session. You review it in the browser, then execute it locally or remotely. For big initiatives. |

---

## 3. Running Work in the Background

| Command | What it does |
|---|---|
| `/background [prompt]` | Detaches the current session to run as a background agent. Your terminal is free. Monitor progress with `/agents`. Alias: `/bg` |
| `/batch <instruction>` | Orchestrates large-scale changes across a codebase in parallel. Claude breaks the work into 5-30 independent units, spawns one sub-agent per unit in an isolated git worktree, each opens its own PR. Requires a git repo. |
| `/tasks` | Shows all background tasks running in the current session. Alias: `/bashes` |
| `/stop` | Stops the current background session. Transcript and worktree are kept. |

---

## 4. Reviewing and Shipping Work

| Command | What it does |
|---|---|
| `/diff` | Opens an interactive diff viewer showing all uncommitted changes. |
| `/review [PR]` | Reviews a pull request locally in your current session. |
| `/security-review` | Analyzes your pending changes specifically for security vulnerabilities. Run before every merge. |
| `/simplify [focus]` | Spawns three parallel review agents that check your changed files for code reuse, quality, and efficiency issues - then applies the fixes. |
| `/ultrareview [PR]` | Deep multi-agent code review running in a cloud sandbox. More thorough than `/review`. |

---

## 5. Session Management

| Command | What it does |
|---|---|
| `/resume [session]` | Resumes a previous conversation by ID or name. Opens a picker if no ID given. Alias: `/continue` |
| `/branch [name]` | Creates a branch of the current conversation. The original is preserved. Alias: `/fork` |
| `/rewind` | Rewinds the conversation (and code changes) to a previous checkpoint. Aliases: `/checkpoint`, `/undo` |
| `/rename [name]` | Renames the current session for easy identification in `/resume`. |
| `/color [color]` | Sets the color of your prompt bar - useful when running multiple sessions simultaneously. |
| `/export [filename]` | Exports the full conversation as plain text. |
| `/copy [N]` | Copies the last assistant response to clipboard. |

---

## 6. Working with IDEs and Desktop

| Command | What it does |
|---|---|
| `/ide` | Manages IDE integrations (VS Code, JetBrains, Cursor, Windsurf). |
| `/desktop` | Continues the current session in the Claude Code Desktop app. Alias: `/app` |
| `/terminal-setup` | Configures terminal keybindings for special shortcuts. |

---

## 7. Connecting Claude to the Web and Cloud

| Command | What it does |
|---|---|
| `/teleport` | Pulls a Claude Code web session into your terminal. Alias: `/tp` |
| `/remote-control` | Makes your terminal session available for remote control from claude.ai. Alias: `/rc` |
| `/schedule [description]` | Creates recurring automated routines that run on Anthropic's cloud infrastructure. Alias: `/routines` |
| `/loop [interval] [prompt]` | Runs a prompt repeatedly while the session stays open. |
| `/autofix-pr [prompt]` | Watches a PR and automatically pushes fixes when CI fails or reviews come in. |

---

## 8. Debugging and Troubleshooting

| Command | What it does |
|---|---|
| `/doctor` | Full health check of your Claude Code installation. Press `f` to have Claude fix issues it finds. |
| `/debug [description]` | Enables debug logging from that point forward. |
| `/rewind` | Rolls back conversation and code changes to a previous checkpoint. |
| `/fewer-permission-prompts` | Scans your past session transcripts and automatically adds common read-only operations to the allowlist. |

---

## 9. Settings, Appearance, and Info

| Command | What it does |
|---|---|
| `/config` | Opens the full settings interface. Alias: `/settings` |
| `/theme` | Changes the color theme. |
| `/status` | Shows version, model, account info, and connectivity. |
| `/usage` | Shows session cost, plan usage limits, and activity stats. Aliases: `/cost`, `/stats` |
| `/insights` | Generates a session analysis report - [here's how to actually use it](/blog/claude-insights-command/). |

---

## 10. Skills and Extensions

| Command | What it does |
|---|---|
| `/skills` | Lists all available skills (built-in + your custom ones). |
| `/plugin` | Manages Claude Code plugins - install, update, remove. |

---

## Architect's Quick Reference

**Starting a session:**
```
/resume          → pick up where you left off
/context         → check how much room you have
/model           → confirm you're on the right model
```

**Before building:**
```
/plan            → map the approach first
/effort high     → crank up reasoning for complex decisions
```

**While building:**
```
/compact         → clean up context when it gets heavy
/background      → detach long-running work
/tasks           → check what's running in background
```

**Before shipping:**
```
/diff            → review what changed
/security-review → catch vulnerabilities
/review          → full PR review
```

**When something breaks:**
```
/doctor          → health check
/rewind          → roll back to a working state
```

Guide compiled for AI Architects Lab - May 2026 cohort. Last updated: 2026-05-16