The Claude Code Slash Command Cheat Sheet Worth Bookmarking

1. Session and Context Management

This is the category you'll reach for most. These commands deal with the state of the conversation, the size of the context, and checkpoints.

/clear — Wipe the conversation clean

Clears the entire current conversation context. Use it when Claude starts confusing files from an earlier session, or when you're moving to something completely different.

The difference from the similar-looking /compact matters. /clear erases every memory and starts from scratch; /compact summarizes the memory to shrink it. A new task calls for /clear; the same task that's grown long calls for /compact.

/compact [instruction] — Save context by summarizing

Summarizes the conversation to reduce context usage. Use it when you're staying on the same task but the session has grown long.

Add an instruction and you decide what gets kept.

  /compact keep only the API decisions
  /compact preserve just the error-handling patterns
  /compact retain only where code changed and why

The general rule of thumb is to run /compact once context usage passes 80%. Since v2.0.64, compaction completes instantly.

/context — Check current context usage

Shows how the context window is being used. Run it once before /compact to see what's taking up your context.

Recent versions also show estimated tokens per skill by model, and the plugin name for plugin-sourced skills. It's the command to answer "why is my context filling up so fast?"

/rewind — Roll back to a checkpoint

Reverts to a previous checkpoint or state. Handy when the conversation is heading the wrong way. Its alias is /undo.

It does the same thing as the Esc + Esc keyboard shortcut, but you can also invoke it explicitly as a command.

/branch [name] — Branch the conversation

Branches the current conversation or workflow. /fork shows up as an alias in some references.

When you've been going in direction A but want to try direction B, creating a branch lets you explore the alternative without losing the original.

/goal — Set a finish line, then run autonomously

Set a completion condition and Claude keeps working across multiple turns until it's met. It works in interactive mode, -p mode, and remote control alike.

Use it when a task has a clear finish line and you want Claude to get there on its own. Elapsed time, turn count, and token usage appear in an overlay panel.

/resume [session name] — Reopen a previous session

Reopens a previous session. It supports named sessions and session titles set with /rename or --name. Press Ctrl+A to show every project.

/rename [name] — Rename the session

Renames the current session. When you're running several tasks at once, give them meaningful names so they're easy to find later.

/status — Check session status

Shows the state of your current session and environment. A good first command to run when you start working.

/diff — View changes

Opens an interactive diff viewer. Use it before a code review or commit to see what changed.

/copy [N] — Copy a response

Copies the most recent response, or a chosen one, to the clipboard. Handy for moving code or generated text somewhere else.

/export [filename] — Export the conversation

Exports the conversation to a file, usually as Markdown. Useful for keeping a record of your work or sharing it with teammates.

/cost — Check cost

Opens cost information. As of v2.1.118 it's been folded into /usage, but it still works as a shortcut — it jumps straight to the cost tab of /usage.

2. Settings and Environment

These commands configure how Claude Code itself behaves.

/init — Generate CLAUDE.md

Generates CLAUDE.md, the project instructions file. One of the most important setup commands there is.

It's the first command to run when you start working a new project with Claude Code. Claude scans the codebase and drafts a CLAUDE.md covering build commands, how to run tests, code conventions, and more. You can refine it by hand afterward.

/config — Open the settings panel

Opens Claude Code's settings. Editor modes (like Vim) are managed in here too.

/memory — Edit memory files

Opens or edits Claude's memory files, including the CLAUDE.md workflow.

When you send a message that starts with #, it gets added to CLAUDE.md — and /memory lets you review and edit that content directly.

/permissions — Manage permissions

Manages permission modes and recently denied commands. When Claude keeps asking for permission or a command gets blocked, adjust the policy here.

/model [model name] — Switch models

Switches the active model. Balance speed against depth depending on the nature of the task.

 /model opus    # hard reasoning, architecture
  /model sonnet  # everyday coding
  /model haiku   # simple exploration

Gateway /v1/models discovery is enabled with the environment variable CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1.

/effort [level] — Adjust the reasoning level

Adjusts reasoning effort. The options are low, medium, high, xhigh, max, and auto.

xhigh works only on Opus 4.7 and above. Run /effort with no argument and an interactive slider appears.

As of March 2026, the default effort level for Max/Team subscribers on Opus 4.6 changed from high to medium.

/fast [on|off] — Fast mode

Turns fast mode on and off. It's not a different model — it runs the same Opus 4.6 with API settings tuned for speed.

Ideal for fast interactive iteration and live debugging. Turn it off when cost matters. Note that switching fast mode on mid-session re-bills your entire prior context at fast-mode rates.

/output-style [style] — Adjust the response format

Changes the response formatting style, switching between concise and verbose output.

/theme — Change the theme

Changes or creates a theme. It supports "auto-match terminal," named custom themes, JSON themes in ~/.claude/themes/, and plugin-provided themes.

/color [color] — Change the accent color

Changes the session's accent color. If remote control is connected, it even syncs the accent color on claude.ai/code.

/scroll-speed — Adjust scroll speed

Adjusts mouse-wheel scroll speed, with a live preview. Useful when scrolling feels off in VS Code, Cursor, or terminal environments.

/tui — Toggle terminal UI mode

Toggles the terminal UI mode. /tui fullscreen renders the same conversation without flicker.

/terminal-setup — Terminal setup guide

Sets up terminal integration. It guides you through configuration such as mapping the Option key to Meta on a Mac.

/keybindings — Configure shortcuts

Creates or edits ~/.claude/keybindings.json. Changes take effect immediately, no restart required.

/hooks — Manage hook scripts

Manages hook scripts and hook events. In recent versions, hooks can call MCP tools with type: "mcp_tool", use the exec-form args: string[], and set continueOnBlock on PostToolUse.

/login, /logout — Authentication

Log in and log out. Use them to clear out an active authentication session.

/doctor — Diagnostics

Runs diagnostics. Useful when something's wrong after an install or upgrade. Press f and Claude fixes the reported issues itself.

/help — Help

Shows help and the available commands. Since the command set changes often, it's the safest command when you're not sure.

/exit — Quit

Quits Claude Code.

3. Skills, Agents, Plugins, and MCP

These commands extend Claude Code.

/agents — Manage subagents

Manages subagents. Running claude agents opens a new agent view that lists every running, blocked, and completed Claude Code session in one place.

/skills — List skills

Lists the available skills. Recent versions let you filter by typing and show the context of plugin-sourced skills more clearly.

Skills are user-defined commands; place them in a .claude/skills/ directory and they work as project-specific slash commands.

/plugin — Manage plugins

Opens plugin management. Plugin details show a component inventory, hook event names, MCP server names, and estimated per-session token cost.

/reload-plugins — Hot-reload plugins

Hot-reloads installed plugins. Useful when testing a plugin. Recent versions pull in plugin-provided skills more reliably, and since v2.1.110 it supports remote control.

/mcp — Manage MCP servers

Manages MCP (Model Context Protocol) servers and also clears dynamic MCP slash commands. On reconnect it picks up edits to .mcp.json without a restart.

The MCP slash-command pattern

Commands are generated dynamically from connected MCP servers.

/mcp__[server]__[prompt] [args]

These commands appear only after the relevant MCP server is connected.

/claude-api — Claude API/SDK workflows

Loads Claude API or SDK helper workflows. Useful for API-related work. Recent versions even cover Managed Agents.

/less-permission-prompts — Permission automation

Scans your transcript for frequently used read-only Bash and MCP tool calls and proposes a prioritized allowlist to add to .claude/settings.json. Added in v2.1.111.

When the constant permission prompts get annoying, running this adds your common, safe commands to the allowlist all at once.

4. Coding, Review, and Planning

These are the commands you'll use most in actual development work.

/plan [description] — Enter plan mode

Switches to plan mode, where Claude only reads and doesn't edit. Use it when you want to talk through the approach before a big change.

The Shift + Tab keyboard shortcut toggles the same mode.

/ultraplan — Precision planning

Runs a more detailed planning workflow. In recent versions, the remote-session flow auto-creates a default cloud environment.

/review — Code review

Reviews your current code changes. One of the most-used coding commands.

/simplify — Multi-agent refactoring

A workflow where several agents refactor in parallel. Great for structural improvements.

If /review is a single review, /simplify is a parallel review from multiple angles. Use it to examine code quality from several perspectives at once.

/ultrareview [PR number] — Comprehensive cloud review

Runs a comprehensive cloud code review with parallel multi-agent analysis and critique. With no argument it reviews the current branch; pass a PR number and it reviews that PR.

/security-review — Security review

Runs a security-focused review. Useful before a merge or release.

/debug [description] — Guided debugging

Runs a guided debugging workflow. Good for tracking a bug down step by step.

/batch — Batch changes

Applies the same change across several files or worktrees. Useful for repetitive edits spanning a whole project.

/loop [interval] — Recurring workflow

Runs a repeated or scheduled workflow. Useful for periodic checks and automation. Its alias is /proactive.

/btw <question> — Side question

Asks a side question without dragging in your entire working context. For quick checks.

You can ask on the side without interrupting work in progress. The answer isn't added to the conversation history and doesn't change the context window.

/usage — Check usage

Shows plan limits, quota usage, cost, and statistics. As of v2.1.118, /cost and /stats are consolidated into tabs inside /usage.

/insights — Usage insights

Shows usage and session insights. Useful for reflecting on your own work patterns.

/focus — Toggle focus view

Turns focus view on and off. It's no longer tied to Ctrl+O.

/powerup — Interactive feature lessons

Opens interactive feature lessons. Added in 2026, it helps you quickly pick up Claude Code's new features.

/release-notes — Release notes

Opens the release notes. Since Claude Code updates weekly, it's the fastest way to keep up with recent changes.

/feedback — Send feedback

Sends feedback. Use it to file a bug report or suggest a feature directly.

5. Git, PRs, and Releases

Commands for branches, commits, pull requests, and release workflows.

/commit — Commit

Generates a commit message and commits. One of the most popular community-built commands.

/pr — Create a PR

Creates a pull request. A common custom/community command.

/push — Push

Pushes the current branch.

/pr-comments [PR] — Fetch PR comments

Fetches GitHub PR comments. The internal underscore form is /pr_comments.

/install-github-app — Set up the GitHub app

Sets up the GitHub app integration.

/fix-pipeline — Repair the CI pipeline

Attempts to repair a failed CI pipeline. A common custom/community command.

/lint — Run the linter

Runs the linting command. Use it to check code style.

/merge-to-main — Merge to main

Handles the merge-to-main workflow.

/vitest — Vitest tests

Runs a Vitest-based test workflow.

6. Integrations, Remote, and Devices

Commands for working across IDEs, browsers, desktop, mobile, and remote environments.

/ide — IDE integration

Opens or manages IDE integration.

/chrome — Chrome integration

Opens Chrome integration. Availability varies by environment.

/desktop — Desktop app

Hands work off to the desktop app.

/rc or /remote-control — Remote control

Starts remote control. /rc is the short form, /remote-control the full name. Remote-session features keep expanding in recent versions.

/remote-env — Configure the remote environment

Configures the remote environment. Recent versions' remote-session planning can auto-create a default cloud environment.

/schedule — Cloud scheduling

Manages cloud scheduled jobs.

/teleport — Transfer a session

Transfers or bridges a session.

/voice — Voice mode

Enables push-to-talk voice mode.

/add-dir <path> — Add a directory

Adds another directory to your working scope. Useful for monorepos or adjacent projects.

7. Diagnostics and Internal Commands

Mostly internal, debug, and experimental commands. Regular users rarely need them, but they're worth knowing about.

/team-onboarding — Teammate onboarding guide

Generates a teammate ramp-up guide from your local Claude Code usage history. Added in v2.1.101. When a new teammate joins, it automatically produces a "here's how our team uses Claude Code."

/sandbox — Sandbox controls

Opens sandbox controls.

/stickers — Stickers

A public but non-essential command.

Internal / leak-based commands

The following commands appear in source references but may not be in the standard public build. Just know they exist.

• /summary — Session summary
• /session — Session management UI
• /share — Share a session
• /env — Environment settings
• /files — Files in context
• /issue — Create a GitHub issue
• /passes — Multi-pass workflow
• /bughunter — Bug-hunting workflow
• /advisor — Architecture advice
• /tasks — Manage background tasks
• /onboarding — First-run onboarding

8. The Categories at a Glance

The 10 you'll use most
/init # first command when starting a new project /clear # switch to a new task

/compact # save context in long sessions /context # check current context usage /model # switch models by task /plan # plan mode before big changes /review # code review /btw # side questions /usage # check cost and usage /help # the safest command when unsure

<Recommended combinations by workflow>

Starting a new project
/init → generate CLAUDE.md /permissions → review the permission policy /add-dir → add the directories you need

Starting a big task
/plan → plan mode /ultraplan → a more precise plan /effort xhigh → top reasoning level

Managing a long session
/context → check current usage /compact → compact once you pass 80% /clear → switch to a new task

Reviewing code
/diff → check the changes /review → basic review /simplify → multi-agent review /security-review → security review /ultrareview → comprehensive cloud review

Git work
/commit → commit /push → push /pr → create a PR /pr-comments → check PR comments

9. A Realistic Order for Learning the Commands

Memorizing 50-plus commands at once isn't realistic. This order is more efficient.

Week 1: five survival commands.
/help, /clear, /compact, /init, /exit. These alone cover the basics.

Week 2: five everyday commands.
/model, /plan, /review, /diff, /context. They speed up the work you do daily.

Week 3: five for integration and automation.
/mcp, /agents, /skills, /hooks, /permissions. They integrate Claude Code into your working environment.

Week 4: five advanced commands.
/ultraplan, /ultrareview, /security-review, /goal, /btw. They handle big jobs and complex reviews.

Learn 20 in a month this way, and from there you can just look the rest up with /help when you need them. Keep the other 30 in the back of your mind and search for them as needed.

10. Building Your Own Commands

Beyond the built-in commands, you can build your own. Just create a Markdown file in the .claude/commands/ directory.

Personal commands

Create them in ~/.claude/commands/ and you can use them across every project.

Project-shared commands

Create them in .claude/commands/ and they're shared with your team through git.

Example: building a /ship command

Save the following to ~/.claude/commands/ship.md.

Review the current diff and run the tests.
  If the tests pass, commit with a clear message and push to main.

Now typing /ship runs that exact workflow. Turning repetitive tasks into commands lets you tailor Claude Code to your own working patterns.

You can use arguments too. Put $ARGUMENTS in the command definition and whatever you pass at call time drops into that spot.

Handle issue #$1 at priority $2.

Calling it with /fix-issue 123 high becomes "Handle issue #123 at priority high."