Feature Index

Shows the built-in help and lists which slash commands this session offers

Asks a quick side question whose answer stays out of the conversation; the left and right arrow keys page through the earlier side answers of the session

Sets up the Claude in Chrome settings that let Claude drive the browser

Discards the conversation so far, which frees up room in the context window

Opens a viewer for changes that are not committed yet; the arrow keys switch between the current git diff and the changes made in individual turns

Opens the settings interface that holds the model, the permissions, and the remaining options of this installation

Opens the settings on the Status tab: version, model, account, connectivity, and which settings sources are currently in effect — even while Claude is still responding

Since v2.1.198 the command no longer opens a management interface; it points you to letting Claude create subagents or editing the files under `.claude/agents` yourself

Lists the available skills from project, user, and plugin sources; typing filters the list by name and the t key sorts it by token count

Shows the active hook configurations for the tool events — the first place to look when an automation does not fire and you want to know what is registered at all

Produces a report on your past sessions: which project areas you work in, how the collaboration goes, and where it runs into friction

Installs the Claude app for Slack; a browser opens so you can finish the OAuth flow

Opens your keyboard shortcuts file for editing — that is where you define your own bindings, including multi-step chords

Shows the connected MCP servers and their status so you can see which external integrations are reachable right now

Edits the `CLAUDE.md` memory files, turns automatic memory on or off, and shows the entries it has collected

Displays a QR code for downloading the Claude app for your phone; `/ios` and `/android` lead to the same place

Gives friends a free week of Claude Code. The command only shows up if your account is eligible for it

Manages plugins: installing, uninstalling, enabling and disabling, updating, and listing. There is no subcommand called remove — uninstalling goes through `claude plugin uninstall`

Switches into plan mode. You can append the task right away (`/plan fix the auth bug`) so Claude starts planning immediately; `Shift+Tab` does the same

Takes the conversation and the code back to an earlier point — or summarizes from a message you pick, instead of rewinding

An alias for `/rewind`, as is `/undo`. There is no separate command for creating checkpoints: the snapshots are taken automatically before every file edit

An alias for `/usage`: shows the cost of the running session, your plan limits, and the activity stats

Shows what is sitting in the context window right now — the basis for deciding whether a `/clear` or a compaction is due

Opens a menu for copying the conversation, messages and tool outputs included, to the clipboard or saving it as a text file

Manages your account usage credits, or requests them from your admin when you run into a limit. The former name `/extra-usage` still works

Bundled skill that takes on the open diff, looking both for genuine bugs and for chances to tidy up. The effort level comes first (`low`, `medium`, `high`, `xhigh`, `max`, or `ultra`), `--fix` applies the findings, `--comment` attaches them as inline comments on the GitHub pull request, and a target at the end narrows the review. For cleanup alone there is `/simplify` as its own skill

Sends product feedback about Claude Code to Anthropic. It opens the same dialog as `/bug`, with the same consent step beforehand

Signs you in to your Anthropic account

Signs you out of your Anthropic account — the way to go when you want to switch accounts

Toggles sandbox mode, which runs commands walled off from the rest of the system. Only available on the platforms that support it

Removed in v2.1.92. To switch between Vim and Normal editing you now go through `/config` and the Editor mode entry

Runs a setup checkup: installation health, invalid settings files, unused extensions, duplicate subagent names in the same directory, and checked-in `CLAUDE.md` content that Claude could derive on its own anyway

Reloads the installed plugins without you having to quit and restart Claude Code

Shows the changelog in a version picker: either the notes for one specific version or all of them at once

Connects the session to Remote Control so you can keep steering it from your phone or the web

Shows the resolved allow and deny rules currently in effect, and lets you change them

Renames the running session and shows the name on the prompt bar. Without an argument Claude derives one from the conversation so far

Switches from the running session into a different conversation

Shows and manages the background work of the current session, finished subagents included. `/bashes` opens the same view

Puts the last response on the clipboard. With a number you reach further back — `/copy 2` takes the one before it

Pulls a Claude Code on the web session into this terminal: a picker appears, then the state is fetched over here

Continues the running session in the Claude Code Desktop app. Requires macOS or Windows and a Claude subscription; `/app` is the same command

Switches the color theme. Besides light and dark variants and colorblind-accessible themes there is `auto`, which follows your terminal background

The shared overview that `/cost` and `/stats` also lead to: session cost, plan limits, and activity figures in one place

Copies the running conversation into a new background session while you keep working here — the copy starts from everything so far

An alias for `/usage`, opened on the Stats tab

Sets up the status line. Describe what it should contain — or call the command without arguments and it derives the line from your shell prompt

Orders Claude Code stickers

Turns fast mode on or off. In non-interactive use (`-p`) the command only takes effect in a session that was already launched with fast mode

Writes terminal keybindings such as `Shift+Enter` for a newline. The command only appears in terminals that need it — VS Code, Cursor, Devin Desktop, Alacritty, Zed

Opens the upgrade page in your browser to move to a higher plan tier. If no browser can be opened, the command shows a sign-in prompt instead

The ordinary mode: before every tool call that needs permission, you get asked

File edits go through without a prompt, while every other kind of tool still asks

Read-only tool access: Claude may look around and plan, but change nothing

Claude works through without prompts; a classifier decides what is defensible unattended. Available on the Team and Enterprise plans

Every permission check is dropped — meant for CI runs and other settings with nobody at the screen

Tools that would need permission are skipped rather than asked about — the route for scripts that must not stall

Built-in agent for multi-step research and for work that stretches across many files; every tool is open to it

Built-in agent that drafts an implementation plan, using read-only tools while it does so

Built-in agent for searching the codebase. It takes on the main session model, but no higher than Opus

Helper agent that steps in to set up the status line as soon as you run `/statusline`. The docs name Sonnet as its model — with no version number

Helper agent for questions about what Claude Code can do; it looks the answers up in the documentation. The docs name Haiku as its model — with no version number

Example of a self-defined agent that goes over changed code looking for quality problems. Not built in — you create it as a file under `.claude/agents`

Self-defined agent as an example: works out the shape of a new feature before any code exists

Self-defined agent as an example: works its way into an existing part of the codebase and explains how it hangs together

Self-defined agent as an example: checks whether changes stay readable and maintainable

Self-defined agent as an example: works out which cases tests need to cover and where the coverage has gaps today

Self-defined agent as an example: writes technical documentation such as interface descriptions and guides

Self-defined agent as an example: goes through changes from the security angle

Self-defined agent as an example: carries a feature from start to finish instead of taking on a single step

Self-defined agent as an example: traces a bug back to its cause instead of patching the symptom

Self-defined agent as an example: writes database queries and interprets what comes back

Example of a self-written skill that kicks off a code review. Whether it applies is decided by its description — there is no separate switch field for that

Self-written skill as an example: checks marketing copy against the tone of the brand

Self-written skill as an example: turns the code into a description of its interfaces

Self-written skill as an example: works through a piece of code systematically and tidies it up

Bundled skill that reviews the changed code for cleanup opportunities and applies the improvements straight away. Bug hunting belongs to `/code-review` — the two are separate skills

Bundled skill for large-scale changes: it studies the codebase, breaks the work into sub-tasks, and has them handled in parallel

Bundled skill that enables debug logging for the session and asks Claude to work out the cause from the log output and the settings paths

Bundled skill that runs a prompt over and over for as long as the session stays open. Without an interval Claude sets its own pace

Bundled skill that loads Claude API reference material for your project language — Python, TypeScript, Java, Go, Ruby, C#, PHP, or cURL

Example plugin for pull-request work: it bundles commands, agents, and an MCP connection of its own into one package

Example plugin for deployment and monitoring — it shows how commands, agents, and an MCP connection can be gathered for one area of work

Example plugin around documentation: commands, agents, and templates in one package that installs in a single step

Example of a connected MCP server: it opens the way to pull requests, issues, and source code through the GitHub interface

Example of a connected MCP server: it takes database queries and hands the results back

Example of a connected MCP server: it adds file operations that reach beyond the built-in tools

Example of a connected MCP server: it wires up Slack for messages and notices to the team

Example of a connected MCP server: it gives access to documents in Google Docs, for reading and for editing

Example of a connected MCP server: it brings projects and tasks from Asana into the session

Example of a connected MCP server: it supplies payment data and the analysis that goes with it

Example of a connected MCP server: it holds on to notes beyond the single session

Example of an external MCP server that looks up library documentation. It does not come from Anthropic and is not built in — you wire it up yourself like any other server

Fires when a session starts or resumes — the place for anything that has to be prepared once up front

Fires once `CLAUDE.md` or a rules file has been read; at this point you can still extend or inspect the loaded instructions

Fires before your input is processed — a good spot to check it or reshape it before it goes on

Fires ahead of every tool call. The classic place for an approval decision or a log entry before anything happens

Fires when the permission dialog appears — which lets you hand the decision to approval logic of your own

Fires after a tool has run successfully — to format the code that was just written, say, or to send a message

Fires after a tool call has failed; this is where error handling goes that should not run on success

Fires when Claude raises a notification — the hookup for channels of your own such as chat or push

Fires when a subagent starts, letting you prepare its surroundings before it receives its first task

Fires when a subagent is done — the point at which you can kick off whatever comes next

Fires once Claude has finished its answer. The usual place for cleanup and for tallies at the end of a turn

Fires when a turn ends because of an API error — a rate limit or an authentication problem, for instance

Fires when an agent on a team has nothing to do, so that new work can be handed to it

Fires as soon as a task is marked done — the place for everything that should happen afterwards

Fires when a new task is created, which makes it useful for logging or for passing the news on

Fires on a change to the configuration, so that dependent settings can be brought in line

Fires when the working directory changes — handy when each directory needs something different prepared

Fires when a watched file changes; useful for triggering a rebuild or a check

Fires before the context is compacted — the last chance to record something that would otherwise be lost

Fires once compaction has finished, which lets you top the shortened state back up

Fires when a git worktree is created — the place for the setup a fresh working copy needs

Fires when a git worktree is removed, so its leftovers get cleaned up along with it

Fires when an MCP server asks you for input; the request can be inspected beforehand

Fires once you have answered such an MCP request, releasing the answer for further processing

Fires when the session ends — the last point for cleaning up and for saving what should survive

Example script on `PreToolUse` for Bash: looks at a shell command before it runs and can turn it down

Example script on `PostToolUse` for writes: checks the file that was written for security-relevant patterns

Example script on `PostToolUse` for writes: formats the file that was just written

Example script on `UserPromptSubmit`: puts the input under scrutiny before it is processed

Example script on `Stop`: records token consumption across several sessions

Example script on `PreToolUse` for Bash: runs the checks that would otherwise sit in front of a commit

Example script on `PostToolUse` for Bash: keeps a log of every shell command that ran

Rules laid down by the organization that apply to everyone automatically — the place for requirements nobody should have to set individually

The memory file in the project root. It gets committed and therefore carries the agreements that hold for the whole team

Directory that lets project rules spread across several files — easier to keep straight than one long file, and shared with the team

The memory file in your home directory. Whatever sits here applies across all your sessions, no matter the project

The same directory idea for your personal rules: several files instead of one, and yours alone

Notes on the project meant only for your machine. The file belongs in `.gitignore` so it never reaches the team

Insights and corrections Claude records on its own initiative, so they are not lost when the session ends

Connects a running session to your phone or the web, so you steer it from there instead of staying at the terminal

Claude Code runs in an environment in the browser, with nothing to install on your own machine

A standalone application for macOS and Windows in which a terminal session can be carried on

Several agents work on related tasks with shared context. Experimental and off by default: you switch it on with `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` in `settings.json` or in the environment — there is no CLI flag for it

The overview of work running in the background — its state, and the chance to step in

Suggestions that arise from the situation at hand and save you the typing

A working copy of its own per undertaking: several branches can be worked on side by side without getting in each other way

Commands run walled off, with limited access to files and network — the compromise between getting things done and staying careful

Blocks individual domains for outbound connections even when a broader allow rule would otherwise let them through

MCP servers can sign in over OAuth instead of having an access key sit in the configuration

Runs the OAuth flow of a configured MCP server from the shell without you having to open `/mcp`; with `--no-browser` it prints the address instead, which is the only way over SSH. The counterpart command discards the stored credentials

Tools from connected MCP servers are no longer all loaded into context up front but searched when needed — which keeps the context clear when many servers are attached

Recurring jobs can be set up instead of being started by hand every time — through the `/loop` skill or the tools for scheduled work

Claude drives a browser in the background — set up through the matching startup flag or the `/chrome` command

Key bindings can be set freely, multi-step chords included; you maintain them through `/keybindings` or directly in `~/.claude/keybindings.json`

Operation without permission prompts, switched on through `--permission-mode auto`. On Bedrock, the Agent Platform, and Foundry this needed an environment variable up to v2.1.206 — since v2.1.207 it does not

An MCP server pushes events into a running session so Claude reacts to nudges from outside; hooking up individual messengers comes as a plugin

Dictate instead of typing: the prompt comes together over the microphone, started from an icon or a key binding

Instead of a shell command, `"type": "agent"` starts a multi-turn verification with tool access. Agent hooks are explicitly experimental and may still change

`"type": "prompt"` has the model make a single evaluation — one question, one answer, no multi-turn run

An MCP server can ask you for input during a tool call instead of giving up with incomplete information

A WebSocket connection stays open in both directions, which suits servers that send events of their own accord. You set one up in `.mcp.json` or with `claude mcp add-json` using the `ws` type. Where a server only answers requests, HTTP is the better pick — WebSocket supports neither OAuth nor the `--transport` flag

A plugin can bring a language server along, so Claude draws on the same language knowledge the editor has

Configuration the organization ships centrally and that takes effect for everyone through managed policy, without anyone setting it individually

Frontmatter field that lets a single subagent run on a different model from the main session — a smaller one, say, for simple and frequent work

Frontmatter field for how hard a subagent thinks. The levels are `low`, `medium`, `high`, `xhigh`, and `max`; which ones take effect depends on the model

Frontmatter field carrying a system prompt the subagent receives at startup — that is how you shape its behaviour before the first task arrives

Frontmatter field that explicitly withholds certain tools from a subagent — the tighter fence for when an allow list would be too coarse

Frontmatter field in a skill YAML header that sets how hard it thinks: `low`, `medium`, `high`, `xhigh`, or `max`

Frontmatter field in a skill YAML header that decides which shell its scripts run under

An alias for `/loop`: runs a prompt repeatedly for as long as the session stays open. Without an interval Claude paces itself

Creates scheduled routines conversationally, changes them, or runs one right away; `/schedule list` shows what is set up

Manifest key pointing at configurations for background monitoring; they arm together with the plugin. It now sits underneath the experimental section

Tool that creates a git worktree of its own and moves into it; given a path argument it enters an existing one instead. `ExitWorktree` leaves again

Experimental interplay of two models: the faster one can ask a stronger one for advice mid-task, rather than handing the whole job over to it

On native macOS and Linux builds, bundled programs take over file and text search — noticeably quicker than the previous implementation

Decides how long session files stick around before they are cleared out on the next startup

At startup the configured MCP servers build their connections alongside each other rather than one after another — with several servers that noticeably shortens the wait

Environment variable that turns on forked subagents: they inherit the full conversation context of the main session, `/fork` behaves accordingly, and every subagent starts in the background

In the input field you can select by character or by line and then work on the selection with the familiar operators — delete, yank, change, put — text objects included

You create named color themes and switch between them; they live as JSON under `~/.claude/themes/`. Plugins can ship some too

`"type": "mcp_tool"` calls a tool on an MCP server that is already connected, without starting a shell for it

The input to `PostToolUse` and `PostToolUseFailure` carries `duration_ms` — how long the tool call took, in milliseconds

Environment variable that blocks every update path, the manual one included. It therefore reaches further than `DISABLE_AUTOUPDATER`, which only stops the automatic route

Put `$defaults` into one of the auto mode lists and your own rules are added to the built-in ones instead of displacing them

Points the pull-request badge in the footer at a review address of your own rather than at GitHub

Environment variable that takes the working directory out of the startup banner — useful while you are sharing your screen

The flag now accepts more than GitHub addresses: GitHub Enterprise as well, plus merge requests from GitLab and pull requests from Bitbucket

Marks a plugin version for release; optionally it pushes straight away, does a dry run only, or overwrites an existing mark

Clears out plugin dependencies that were installed automatically and that no installed plugin needs any more. Whatever you installed yourself is left alone; `autoremove` is the same command

Exempts an MCP server from the on-demand tool search so its tools sit in the context from the start

Environment variables that decide which concrete model names sit behind the Haiku, Sonnet, and Opus tiers

Skips the confirmation a CLI command would otherwise wait for — documented for `claude auto-mode reset`, among others. Not every command knows the flag; when in doubt, `--help` on that command settles it

Runs the deep cloud review non-interactively, from CI or a script. The findings go to stdout, unformatted with `--json`, and the exit status tells success from failure

A skill can read the effort level currently in force from inside its own text and adapt its approach to it, instead of hard-coding one level

A `PostToolUse` hook can replace a tool output through `hookSpecificOutput.updatedToolOutput`. That used to apply to MCP tools only and now applies to all of them

Environment variable for the Bedrock service tier you want; the value travels along as a header entry of its own on the request

Managed setting that blocks the direct invocation of shell commands, no matter whether it comes from a skill, a command you defined, or a plugin

Environment variable passed down to subprocesses so that outside tools can tell the request came from Claude Code

Managed policy that restricts plugin marketplaces — `hostPattern` filters by domain, `pathPattern` by repository path

Deletes all the state stored for a project — sessions, memory, and cached data. A dry run shows beforehand what would be affected

Startup flag that bypasses every permission prompt and so matches the `bypassPermissions` mode. The blunt name is deliberate: it is there to remind you of the price

Sign-in path for environments where the browser cannot reach the local callback — WSL2, SSH sessions, containers. You paste the code you receive by hand instead of waiting for the redirect

Even with prompts skipped, writes to `.claude/skills/`, `.claude/agents/`, and `.claude/commands/` stay allowed without being asked about

Caps the runtime of that same review in minutes; when the time is up, whatever has been found so far comes back

Decides what a new worktree branches from — the default branch on the remote, or the state you currently have checked out

Managed settings for Linux and WSL2 that pin the absolute paths of the two sandbox helper programs rather than letting them be discovered

Managed setting governing whether settings from a surrounding environment — SDK or editor — merge with the ones administration rolls out or are overridden by them

Hook commands get the effort level currently in force as an environment variable, so a hook can adapt its behaviour to it

Bash subprocesses get the effort level currently in force as an environment variable, so a script can adapt its behaviour to it

Environment variable holding the unique session identifier, set in Bash subprocesses and in hooks — which lets you attribute events to a session

Environment variable that switches off the fullscreen renderer. The conversation then stays in the terminal ordinary scrollback

While a pasted image is being read from the clipboard, a short hint about it appears in the status bar

Fetches a plugin as a ZIP archive from an address and uses it for the running session only — with no permanent installation

Environment variable that forces synchronized output even where automatic detection of the terminal falls short

Environment variable that turns on background updates for installations through Homebrew and WinGet; when a new version is ready you are prompted to restart

Environment variable that fills the model picker from the model endpoint of an upstream LLM gateway instead of pinning it

Managed setting that unlocks the notification channels for the organization — without it the matching plugins have no effect

Environment variable holding a personal GitHub access token. It belongs to the `gh` CLI and is picked up in cloud sessions for repository access

Environment variable holding the hostname of a GitHub Enterprise Server installation. It too comes from the `gh` CLI rather than Claude Code — its own documentation is where to look

Environment variables for signing in to a GitHub Enterprise Server instance, read by the `gh` CLI once the hostname points at an enterprise server

Names the condition under which the job counts as done, and Claude keeps at it over several turns. While that runs, an overlay reports elapsed time, how many turns have gone by, and the tokens spent

Lists what a plugin contains — skills, agents, hooks, MCP servers — and what it is likely to cost in tokens per session

Opens the overview of all Claude Code sessions with their state — working, waiting, completed, failed, idle, or stopped — and their latest activity

When `args` is given as an array, the hook command starts directly, with no shell in between. Leave the field out and the command goes to the shell to be split up

Environment variable that switches off background sessions and the overview that goes with them

Environment variable that caps how many turns a session may take — the brake for automated runs that would otherwise keep going

Environment variable after which the caret at the input position is the one the terminal itself draws, rather than the block Claude Code paints there

Environment variable that replaces the message inserted when a session that broke off mid-turn is resumed

Environment variable that sends the session quality survey to an OpenTelemetry collector of yours, for setups where nonessential traffic towards Anthropic is turned off

Flag for `claude agents` that narrows the overview to sessions below a given working directory — handy when several repositories are open at once

Starts the session in the permission mode you want, overriding whatever the settings hold as the default

Workspace identifier for signing in through workload identity federation — needed once the rule covers more than one workspace

Set to `1`, plugin sources of the form `owner/repo` are cloned over HTTPS rather than SSH. Meant for CI runs and containers where no SSH key is present

Turns a disabled plugin back on without reinstalling it. The scope is chosen with `--scope user|project|local`, and it is addressed as `<plugin>` or `<plugin>@<marketplace>`

Turns a plugin off without uninstalling it — handy for parking it in one scope while carrying on with it elsewhere

Takes further working directories into the session for Claude to read and edit. Each path has to exist as a directory; to keep them permanently you put them in the settings instead

Draws the MCP server descriptions from one or more files in JSON form. Paired with `--strict-mcp-config`, nothing but those files counts for that run

Unlocks the PowerShell tool on Linux, macOS, and WSL provided `pwsh` version 7 or newer is on the path; on Windows the same variable opts back out

Prints the same session roster in machine-readable form as a JSON array: `pid`, `cwd`, `kind`, and `startedAt` always, plus `sessionId`, `name`, and `status` where set. Background sessions additionally carry `id` — which is how you address them in `claude attach`, `claude logs`, and `claude stop` — along with `state`. Meant for scripts such as a custom status bar or a restore-on-boot script

The inputs to `Stop` and `SubagentStop` carry `background_tasks` with the background work still running and `session_crons` with the scheduled jobs that are queued

The overviews in `/plugin` show a plugin commands, agents, skills, hooks, and MCP and LSP servers before you install, so you know what you are taking on

Where reading a whole file would blow the token limit, a shortened first page comes back carrying a `PARTIAL view` notice — instead of a hard error

Changes how Claude answers — role, tone, and shape — by way of the system prompt. Alongside the ones that ship with it you can define your own

Claude opens applications and works interfaces on macOS. You unlock it through the matching MCP server in `/mcp`

When you come back to the terminal after a break, one line sums up where the work stands. `/recap` fetches that summary any time; `/config` switches it off

Steps back through the command history interactively. In the fullscreen renderer the same key opens a search dialog instead — and only there does `Ctrl+S` cycle the scope between this session, this project, and all projects

With Remote Control connected, Claude reaches you on your phone when a task is done or needs a decision. You switch it on in `/config`

Rules in `autoMode.hard_deny` block an action in auto mode without exception — even where an allow rule or the evident intent would speak for it. The place for the limits that should never give way

Bundled skill that goes through your transcripts, spots the read-only Bash and MCP calls you make often, and drafts an allowlist for `.claude/settings.json` ordered by how much each entry saves

Setting under which a `PostToolUse` rejection reaches Claude as further context and the turn keeps running rather than stopping — meant for checks you want work to continue after

Claude writes a JavaScript script that coordinates many subagents and lets it run in the background — meant for work that breaks down into many similar parts

Bundled dynamic workflow that researches a question from several directions on the web, weighs the sources it finds against each other, and ends with a cited summary

Effort level that pairs very high reasoning with orchestration of its own: Claude plans a dynamic workflow for every substantial task without you asking for one

Moves the session to a different working directory without the prompt cache being thrown away mid-task

Starts Claude Code with no customization at all — no `CLAUDE.md`, plugins, skills, hooks, or MCP servers. The first thing to reach for when it is unclear where a misbehaviour comes from

A chain of fallback models tried in order when the first is overloaded, unavailable, or answers with an error that is not worth retrying