Cancels whatever is happening right now — clears typed input, or stops a response that's still generating.

Exits the current session and returns you to your regular shell.

Clears the terminal screen without touching the conversation itself.

Opens reverse-search so you can find and re-run something you typed earlier.

Autocompletes file paths, slash commands, and @ mentions as you type.

Steps backward and forward through this session's input history.

Cycles the permission mode: default (asks before edits) → auto-accept edits → plan mode (research only, no edits).

Cancels the current input before you've sent it.

Rewind — press twice to jump back and edit an earlier message, undoing everything that happened after it.

Sends the current message to Claude.

Pastes an image straight from your clipboard — handy for sharing screenshots or mockups.

Inserts a newline in your message instead of sending it, for multi-line prompts.

Starts a slash command — built-in tools like /clear, /init, or /model.

Runs a bash command directly against your shell, bypassing the model entirely.

Appends a quick note to memory (CLAUDE.md) without breaking your flow.

Mentions a specific file so Claude reads it straight into context.

Wipes the conversation and starts completely fresh, keeping your working directory the same.

Summarizes older context to free up space so long sessions don't run out of room. Point it at a topic to keep that part detailed.

Prints how many tokens this session has used and roughly what it cost.

Lists your recent sessions so you can jump back into one instead of starting over.

Shows your signed-in account, active model, and connection health at a glance.

Exports the full conversation transcript to a file you can share or archive.

Scans the current codebase and writes a starter CLAUDE.md so future sessions understand your project immediately.

Opens interactive settings for the CLI — theme, notifications, and defaults.

Shows which tools are allowed, denied, or ask-first, and lets you edit the rules.

Installs terminal key bindings so shortcuts like Shift+Enter behave correctly.

Switches the input editor to Vim-style modal keybindings.

Runs a health check on your installation and configuration, and flags anything broken.

Opens the manager for custom subagents — create, edit, or remove specialized helpers.

Configures hooks that fire automatically on events like a tool running or a session starting.

Lists connected MCP servers and lets you authenticate or reconnect them from inside a session.

Opens your CLAUDE.md files directly for editing, instead of asking Claude to update them.

Grants the current session access to another directory outside the one you started in.

Connects the session to a supported IDE extension for inline diffs and selections.

Signs in to your Anthropic account.

Signs out of the account currently in use.

Switches which model handles the rest of this session.

Reviews an open pull request and leaves structured feedback.

Pulls in review comments from a pull request so Claude can act on them directly.

Runs a security-focused pass over your pending changes before you ship them.

Reports a bug straight to Anthropic, including relevant session context.

Starts an interactive session in the current directory.

Starts a session with an initial prompt already queued up, ready to run.

Print mode — runs once, prints the result, and exits. Built for scripts and pipelines, not conversation.

Picks up your most recent conversation right where it left off.

Shows a list of previous sessions so you can choose one to resume.

Sets which model handles this run.

Grants access to an extra directory beyond the current working folder.

Sets the starting permission mode: default, plan, acceptEdits, or bypassPermissions.

Whitelists specific tools Claude is allowed to use in this run.

Blacklists specific tools, even if they'd otherwise be permitted.

Returns structured JSON instead of plain text — built for piping into other tools.

Caps how many back-and-forth turns a non-interactive run can take before stopping.

Loads a specific set of MCP servers from a config file for just this run.

Shows detailed logging for every tool call, useful when debugging automation.

Skips every permission prompt. Only use inside an isolated sandbox — never on a machine with real data.

Assigns a specific ID to the session, so you can reference or resume it precisely later.

Branches off a copy of an existing session instead of continuing it in place.

Loads settings from a specific file instead of the default settings.json.

Adds extra instructions on top of the default system prompt for this run.

Accepts streaming JSON input, for feeding messages in programmatically.

Registers a new local MCP server that runs as a subprocess.

Connects a remote server over HTTP — the recommended transport for hosted servers.

Connects a remote server over Server-Sent Events, for servers that stream responses.

Lists every MCP server configured for this project, with its connection status.

Shows the full configuration and status for one specific server.

Removes a server from the project's configuration.

Passes an environment variable through to a local MCP server when adding it.

Available only to you, only in this project. Stored in your personal ~/.claude.json.

Shared with your whole team — checked into version control alongside the code.

Available globally, across every project on your machine, regardless of which repo you're in.

Opens an interactive panel to inspect, authenticate, or reconnect servers without leaving the chat.

A server config flag that keeps it connected and trusted across sessions, skipping repeat approval prompts.

Project memory — conventions, architecture notes, and context shared with your whole team via git.

Your personal notes for this project. Not committed, so it stays out of your teammates' way.

Global memory that applies no matter which project you're working in.

Project-level settings — permissions, hooks, and defaults — checked into git so the whole team shares them.

Your personal overrides for this project. Gitignored by default.

Defines a custom subagent — its own system prompt, tool access, and area of expertise — that the main session can delegate to.

Defines a reusable skill: packaged instructions for a specific task, triggered by name or by description matching.

The mechanism the main agent uses to hand off a chunk of work to a subagent, often running in the background.

The parameter that picks which agent persona — general-purpose, a custom one, or a built-in specialist — handles a delegated task.

The name and description fields at the top of a skill file, which is how Claude decides when to trigger it automatically.

A frontmatter field that restricts exactly which tools a skill or subagent is permitted to use.

Fires right before a tool runs — can inspect the call and block it before anything happens.

Fires right after a tool finishes, useful for logging, formatting, or triggering a follow-up check.

Fires the moment you submit a message, before Claude sees it.

Fire when a session opens or closes — handy for setup and cleanup scripts.

Fires when Claude finishes responding, before control returns to you.

Your API key, used to authenticate requests when you're not signed in interactively.

Overrides the default model for every session, without passing --model each time.

Opts out of anonymous usage analytics.

Turns off automatic updates, useful for pinned or managed environments.

Routes model requests through AWS Bedrock instead of the Anthropic API directly.

Routes model requests through Google Vertex AI instead of the Anthropic API directly.

Sends all network traffic through a proxy — standard for locked-down corporate networks.

Let Claude read and understand the codebase before it writes a single line — the highest-leverage habit there is.

Shift+Tab into plan mode to get a proposal before anything is edited, so you can course-correct for free.

Hit Esc the moment an approach looks wrong, rather than letting a bad direction run to completion.

Drop in a mockup or a bug screenshot for UI work — Claude reads images directly, no description needed.

Put conventions in CLAUDE.md so every future session inherits them instead of you re-explaining.

Use Esc Esc to rewind after Claude heads down the wrong path, instead of trying to talk it back.

Use subagents for independent research so the main thread stays focused on the task at hand.

A tight, high-signal memory file gets read carefully; a sprawling one gets skimmed.

Spin up a fresh subagent to review a risky change independently, without the original context biasing it.

Generates a new UI component that matches the project's existing props, styling, and file conventions.

Checks a component against WCAG basics — contrast, ARIA labels, keyboard navigation, and focus order.

Renders a layout at mobile, tablet, and desktop widths and flags overflow, clipping, or broken wrapping.

Keeps colors, spacing, and typography aligned with the project's design tokens instead of one-off values.

Flags state that's colocated wrong, causing unnecessary re-renders or prop-drilling.

Flags a new dependency or import that meaningfully grows the client bundle.

Generates a new endpoint with validation, error handling, and types matching project conventions.

Writes or reviews a database migration for backward compatibility, locking, and missing indexes.

Scans changed code for injection, auth bypass, leaked secrets, and unsafe deserialization.

Confirms request and response bodies are validated against a schema, not just typed.

Ensures errors are caught, logged, and returned in one consistent shape across endpoints.

Verifies new endpoints have rate limiting and abuse protection appropriate to their cost.

Finds code paths touched in a diff that have no test covering them.

Writes an end-to-end test for a critical user flow, like checkout or signup.

Investigates a flaky failure and finds the real cause — timing, ordering, or leaked state.

Turns a vague bug report into a minimal, reliable reproduction case.

Generates a manual QA checklist straight from a diff, before sign-off.

Compares before/after screenshots and flags unintended visual regressions.

Suggests the right easing curve and duration for an interaction — entrance, exit, hover, drag.

Adds a prefers-reduced-motion fallback so a new animation degrades gracefully.

Profiles an animation for jank and suggests fixes — compositing, will-change, layout thrashing.

Specs a hover, press, or focus micro-interaction, including timing and every state.

Reviews scroll-linked animations for performance and motion-sickness triggers.

Checks that transition durations and easings match the project's motion system.