Claude Code

Clear conversation history and free context window

Compact conversation context. Optional focus text tells Claude what to preserve.

Branch the conversation into a new named thread

alias: /fork

Show token usage, cost, and cache breakdown for the current session. Replaces /cost and /stats.

Visualize context window usage as a grid — see what's consuming space

Open an interactive diff viewer for current changes

Copy the last (or Nth) response to clipboard

Summarize session context when returning after a break

Undo the last action, including file edits and bash commands

alias: /undo

Export the current conversation to a file

Enter plan mode — Claude presents a plan before executing any action

Resume a previous session by ID or name

Toggle focus view in fullscreen terminal mode

Show token usage and estimated cost (deprecated — use /usage instead)

Switch the AI model. Use ← → arrows to also adjust effort level. Selection persists across restarts.

Toggle fast mode — Opus 4.6 with faster output (not a model downgrade)

Create and switch named custom themes, including "Auto (match terminal)" dark/light mode

View and update tool permissions for this session, including recent auto-mode denials

Set effort level: low / medium / high / xhigh / max. Opens interactive slider when called without args.

Set the prompt-bar accent color

View and customize keyboard shortcuts

Install recommended terminal integrations (shell hooks, key bindings)

Create a CLAUDE.md in the current project to give Claude persistent context

Edit CLAUDE.md files, toggle auto memory, and view current memory entries

Open the MCP server management UI — add, remove, and inspect servers

View and manage Claude Code lifecycle hooks

List available built-in and custom skills

View and manage agent configurations

Review the current git diff (or a specific PR) using code review heuristics

Deep multi-agent cloud code review. No args reviews local diff; PR# reviews a GitHub PR.

Code review + fix workflow using 3 parallel agents

Scan the current diff for security vulnerabilities

Add the current session's tool usage to the allowlist to reduce future permission prompts

Schedule a recurring task at a set interval. Alias /proactive.

Open Claude Code's Chrome integration settings

Show IDE integration status (VS Code, JetBrains)

Hot-reload all plugins without restarting Claude Code

Add an additional working directory to this session's allowed set

Check Claude Code installation health and diagnose issues

Ask a side question without adding it to the conversation context. Zero context cost.

Request extra usage capacity when rate limited

Toggle push-to-talk voice dictation (20 languages supported)

Analyze your session history and generate a usage report

Continue the current session in the Claude Desktop app

Rename the current session

Show all available slash commands and keyboard shortcuts

Submit feedback or report a bug to Anthropic

alias: /bug

Start an interactive Claude Code session

Start a session with an initial prompt pre-filled

Non-interactive (headless/SDK) mode — print response and exit

Continue the most recent conversation session

Resume a session by ID or name

Update Claude Code to the latest version

Sign in to your Anthropic account (supports --sso and --console flags)

List all configured agent definitions

Manage MCP server configuration

Plugin management — install, remove, and list plugins

Non-interactive mode — print response to stdout and exit. Use with --output-format for scripting.

alias: -p

Continue the most recent conversation session

alias: -c

Resume a specific previous conversation by ID or name

alias: -r

Set a name for this session (makes it easier to resume later)

alias: -n

Print the installed version number and exit

alias: -v

Show help information and available flags

alias: -h

Specify the Claude model (e.g. claude-opus-4-7, claude-sonnet-4-6, claude-haiku-4-5-20251001)

Set thinking effort: low / medium / high / xhigh / max

Output format for --print mode: text (default), json, streaming-json

Constrain --print output to a specific JSON schema (structured output)

Maximum number of agentic turns before pausing for input

Cap total spend for this session (e.g. --max-budget-usd 5)

Override the default system prompt (use with --print)

Append additional text to the default system prompt

Launch with a specific named agent configuration

Define one or more agents inline as a JSON string

Permission mode: default (prompts) · acceptEdits (auto-accept edits) · plan (read-only) · auto · dontAsk (deny unless allowed) · bypassPermissions (skip all)

Comma-separated list of tools Claude is allowed to use without prompting

Comma-separated list of tools Claude cannot use in this session

Add bypassPermissions to the Shift+Tab permission mode cycle

Bypass all permission prompts. Only use in trusted, sandboxed CI environments.

Add an additional directory to Claude's allowed working set

alias: -a

Path to a custom MCP configuration file (overrides default .mcp.json)

Load a specific settings JSON file for this session

Disable all MCP server connections for this session

Minimal mode — no hooks, MCP servers, or memory files loaded

Exclude dynamic context from prompt caching to improve cache hit rates

Start a web session on claude.ai instead of running locally

Enable Remote Control mode for external orchestration

alias: --rc

Enable IDE integration mode — used by VS Code and JetBrains extensions

Enable Chrome browser integration

Disable Chrome browser integration for this session

Enable MCP push notification channels

Show full turn-by-turn conversation including system messages

Enable debug-level logging, optionally filtered by a keyword

Cancel current input or interrupt a running generation

Exit the Claude Code session

Clear prompt input and force a full screen redraw

Toggle transcript viewer showing verbose tool usage; cycles focus in fullscreen

Clear the entire input buffer

Restore the last cleared input buffer

Open current input in your $EDITOR (same as Ctrl+X Ctrl+E)

Reverse-search command history (standard bash Ctrl+R)

Kill all background agents. Press twice to confirm.

Show background running tasks

Toggle the task list panel

Rewind the last action or summarize the session

Cycle through permission modes: default → acceptEdits → plan → …

Insert a newline without submitting — for multi-line input

Enter vim visual mode (character selection + operators) in the prompt editor

Enter vim visual-line mode in the prompt editor

Start a slash command (e.g. /clear, /compact, /help)

Run input directly as a bash command without Claude interpreting it

Mention a file — triggers autocomplete for file paths in the project

Switch the active model

mac only

Toggle extended thinking on/off

mac only

Toggle fast mode on/off

mac only

Move cursor one word to the left

mac only

Move cursor one word to the right

mac only

Delete the word to the left of the cursor

mac only

Move cursor to beginning of line

mac only

Move cursor to end of line

mac only

Anthropic API key for direct API access. Set this to use your own key instead of the logged-in account.

Alternative to ANTHROPIC_API_KEY. Bearer token for API authentication.

Override the Anthropic API base URL. Useful for proxies or enterprise gateways.

Comma-separated list of additional beta feature headers to send with API requests.

Add a custom model ID as an entry in the /model picker.

Route requests through AWS Bedrock instead of the Anthropic API direct endpoint.

Route requests through Google Cloud Vertex AI instead of the Anthropic API.

AWS named profile to use when CLAUDE_CODE_USE_BEDROCK is set.

AWS region for Bedrock (e.g. us-east-1). Required when using Bedrock.

Path to GCP service account JSON key file when using Vertex AI.

Set to 1 inside a Claude Code session — use to detect Claude Code in shell scripts.

Override the maximum thinking token budget. Set to 0 to disable extended thinking.

Override the default maximum output tokens per response.

API request timeout in milliseconds. Default is 600000 (10 minutes).

MCP server startup timeout in milliseconds.

TTL in milliseconds for API keys fetched via an external helper script.

Disable all non-essential network requests — telemetry, update checks, stats pings.

Suppress model calls not directly requested by the user (e.g. auto-summaries).

Force a session recap when telemetry is disabled (normally auto-detected).

Prevent Claude Code from auto-checking and installing updates.

Block all update paths — auto-updater and manual update commands.

Disable the /feedback command and remove bug reporting functionality.

Opt out of automatic error reporting sent to Anthropic.

Opt into the 1-hour prompt cache TTL (longer cache, better hit rates for long sessions).

Force the 5-minute prompt cache TTL even when the 1-hour TTL is available.

Disable prompt caching. Claude Code shows a startup warning when this is set.

Disable the 1M token context window even on models that support it.

Override the context percentage threshold that triggers auto-compact (default ~95%).

Set the rolling window size (in tokens) for auto-compact thrash detection.

Disable the auto memory system — Claude will not automatically save or load memory files.

Enable forked subagents on external builds for improved isolation.

Disable all scheduled (cron-style) tasks defined in settings.

HTTP proxy for outbound connections (e.g. http://proxy.corp.example:8080).

HTTPS proxy for outbound connections.

Comma-separated list of hostnames to bypass the configured proxy.

Path to a custom certificate store for TLS verification in corporate environments.

Enable detailed usage telemetry collection. Off by default.

Suppress the warning shown when running with elevated permission modes.

Cycle permission modes: Normal → Auto-Accept Edits → Plan (read-only) → …

Enter plan mode for the current request. Claude presents a plan before executing.

Start Claude Code in plan mode via CLI flag — good for CI review pipelines.

Plan files are named after your prompt (e.g. fix-auth-race-snug-otter.md) and saved in the project.

Include "think" in your prompt to enable extended thinking for deeper reasoning.

Higher thinking budget — more thorough reasoning on complex problems.

Near-maximum thinking budget. Use for the hardest architectural or algorithmic problems.

Maximum thinking budget. Alias for "think harder". Slowest and most thorough.

Toggle extended thinking on/off without changing your prompt.

mac only

Open transcript viewer to see thinking output (verbose tool usage view).

Set effort level interactively: ○ low · ◐ medium · ● high · ★ xhigh · ★★ max

Set thinking effort for non-interactive (--print) mode. low/medium/high/xhigh/max.

Enable push-to-talk voice dictation. Claude transcribes speech in 20 languages.

Hold to record your message, release to send it (when voice mode is active).

EN, ES, FR, DE, CZ, PL and 14 more — auto-detected from your speech.

Visualize context window usage and get optimization tips.

Compress conversation history with optional focus — preserves key decisions.

Wipe conversation history entirely. Full context window reset.

Triggers automatically at ~95% context capacity. Includes thrash detection (3x threshold).

Opus 4.6 supports 1M token context on Max, Team, and Enterprise plans.

Memory files survive compaction — always re-loaded after a /compact or auto-compact.

Open the permissions panel — the Recent tab shows all recently denied tool calls.

Retry a denied tool call from the Recent tab after reviewing and approving it.

Create a git worktree for an isolated checkout. Claude can work here in parallel.

Start Claude Code scoped to a named worktree branch.

Agent frontmatter — run the agent in its own temporary git worktree.

Sparse checkout — check out only the directories needed for the task.

Status line JSON field — contains the linked worktree path when inside a worktree.

Auto-creates 5–30 worktrees to run large parallel changes across the codebase.

Continue the most recent conversation from the terminal.

Resume a named session from the terminal — use /rename to name sessions.

Ask a side question without adding it to the conversation — zero context cost.

Ask Claude to summarize the session so far — useful when returning after a break.

Run non-interactively, print response to stdout, and exit.

Output structured JSON — good for parsing response in scripts.

Read prompt from stdin — compose complex prompts in shell pipelines.

Allow up to N agentic turns before stopping.

Cap total API spend for this headless run.

Run a recurring task every 5 minutes (supports s, m, h units).

Start a web session on claude.ai instead of running locally.

Add a stdio MCP server by command. Defaults to user scope.

Add a remote HTTP MCP server by URL (recommended for remote servers).

Add a remote SSE MCP server by URL.

Add a project-scoped MCP server (stored in .mcp.json, shareable via git).

Add a local-only server (user settings, overrides project scope, not committed).

Remove a named MCP server from configuration.

List all configured MCP servers and their connection status.

Show full configuration details for a specific MCP server.

Reset saved MCP server approval decisions for the current project.

Open the interactive MCP server management UI inside Claude Code.

Remote HTTP transport (recommended). Server exposes REST endpoints; Claude makes HTTP requests.

Local process transport (default). Server runs as a child process, communicates via stdin/stdout.

Server-Sent Events transport. Server runs independently; Claude connects to its URL.

Stored in ~/.claude.json. Applies to you only — not shared. Default scope when adding servers.

Stored in .mcp.json at the project root. Commit this to share servers with your team.

Stored in ~/.claude.json globally. Active across all projects for your account.

Project-level MCP config at the repo root. Commit this to share servers with your team.

User-level config file. Stores OAuth tokens, MCP server definitions, and session state.

Set _meta["anthropic/maxResultSizeChars"] in a tool result to raise the per-tool text threshold up to 500K chars.

Project-level memory at the project root. Commit this to share context with your whole team.

Alternate project-level location inside the hidden .claude directory.

Local personal project notes — gitignored, not shared with the team.

User-level memory. Loaded for every project. Good for personal coding preferences.

Managed policy file (Linux/WSL). Set by IT/DevOps — applies org-wide, users cannot override.

Directory-level memory. Loaded when Claude operates in or below that subdirectory.

Project-level rules files. Loaded for matching paths or globally if no paths filter is set.

User-level rules files. Applied across all projects.

YAML frontmatter in a rules file: limit the file to specific path patterns (e.g. ["src/**/*.ts"]).

Import another file's contents into CLAUDE.md. Path is relative to the CLAUDE.md file location.

Import a user-level shared file into any project CLAUDE.md — useful for shared team rules.

Auto memory directory for a project. MEMORY.md auto-loads at startup (first 25KB / 200 lines); topic files load on demand.

Disable the auto memory system entirely.

What the project does, its stack, and key architectural decisions.

Build, test, lint, and deploy commands. Claude reads these to avoid asking.

Naming conventions, formatting preferences, and patterns to follow or avoid.

Key files Claude should always be aware of (entrypoints, config, schemas).

Explicit list of actions Claude should never take in this project.

User-level settings. Applies to all projects. Do not commit this file.

Project-level settings. Safe to commit — shared with team via git.

Local project overrides. Add to .gitignore — machine-specific config only.

OAuth tokens, MCP server state, and other runtime state managed by Claude Code.

Project MCP server definitions. Commit this to share MCP servers with your team.

Drop-in policy fragments directory. Files here are merged in alphabetical order.

Array of tool patterns Claude can use without prompting. E.g. ["Bash(git *)", "Read", "Write(**/*.ts)"]

Array of tool patterns always blocked. Overrides the allow list. E.g. ["Bash(rm *)"]

Default model to use for this project or user scope.

Map model picker names to custom model IDs — e.g. { "claude-opus-4-7": "my-custom-opus" }.

Override the default directory for auto memory storage.

Map of MCP server configs: { name: { command, args, env, scope } }

Environment variables automatically injected into every Claude Code session.

Shell commands triggered on lifecycle events: PreToolUse, PostToolUse, Stop, SubagentStop, Notification, PermissionDenied.

Conditional hook execution using permission rule syntax — only run the hook when the condition matches.

Pause a headless session and wait for external input before resuming.

Hook step that invokes an MCP tool directly instead of running a shell command.

Show extended thinking summaries in the transcript viewer. Off by default — opt in to see them.

Admin allowlist for which channel plugins users may install.

Block !`cmd` dynamic context injection in skills — prevents shell execution inside skill prompts.

Sparse checkout paths for git worktrees — only check out specified directories.

Exit with an error if the sandboxed execution environment is not available.

Re-run the custom status line command every N seconds to update it dynamically.

Runs before Claude executes any tool. Can block execution by exiting non-zero.

Runs after a tool completes. Receives tool name and result in environment.

Runs when Claude finishes responding and returns to the prompt.

Runs when a spawned sub-agent completes.

Runs when Claude sends a notification (e.g. "waiting for input").

Runs when a tool call is denied in auto/dontAsk mode — useful for logging or alerting.

Managed policy on Linux/WSL. Set by IT/DevOps; applies org-wide.

Managed JSON policy on Linux and macOS. Overrides all user and project settings.

Managed policy on Windows.

Create or update a CLAUDE.md for the project

Code review heuristics on the current git diff or a specific PR

Deep multi-agent cloud review — parallel analysis of a diff or GitHub PR

Code review + fix using 3 parallel agents

Scan the current diff for security vulnerabilities

Large parallel changes using 5–30 git worktrees automatically

Troubleshoot from debug log output

Schedule a recurring task at a set interval

Load Claude API and SDK reference into context

Project-level skill. Active only in this project.

User-level skill. Available across all projects.

When to auto-invoke this skill. Claude reads this to decide which skill to activate.

Tool allowlist for this skill — lets it skip per-tool permission prompts.

Override the model for this skill (e.g. claude-opus-4-7). Inherits from parent if omitted.

Override the effort level for this skill: low / medium / high / xhigh / max.

Limit skill activation to specific file paths (YAML list, e.g. ["src/**/*.ts"]).

Run this skill in a subagent (isolated context) rather than the main session.

Placeholder for user-provided arguments when the skill is invoked with extra text.

Expands to the skill's own directory path — useful for referencing skill-local files.

Dynamic context injection — run a shell command and insert its output into the skill prompt.

Ship executables in a bin/ subdirectory that the Bash tool can call during the skill.

Default agent. Full tool access. Use for broad multi-step tasks.

Fast read-only agent (Haiku model). Glob, Grep, Read, WebFetch only. Good for codebase research.

Architect agent for designing implementation plans. No write tools — analysis only.

Terminal agent with a separate context. Specialized for shell-heavy tasks.

Short label shown in the UI when the agent is running (3–5 words).

The task for the agent. Brief it like a colleague — include context, goal, and constraints.

References a named skill to give the spawned agent specialized capabilities.

Optional model override for this agent (e.g. claude-haiku-4-5-20251001 for speed).

true — spawn the agent asynchronously and continue without waiting for it.

"worktree" — agent works in an isolated git worktree. Auto-cleaned if no changes made.

default · acceptEdits · plan · dontAsk · bypassPermissions

Run this agent in a dedicated git worktree for full isolation.

Enable persistent memory for this agent — stored at user, project, or local scope.

Run as a background task — caller continues immediately without waiting.

Hard limit on the number of agentic turns this agent can take.

Automatically submit this prompt when the agent starts (no user interaction needed).

Resume a running or paused agent by sending it a message (replaces the old resume API).

Mention a named subagent in a prompt to delegate part of the task to it.