Claude Code Cheat Sheet

Installs the Claude Code CLI globally with npm. Anthropic also ships a native installer script; either route ends with a claude command on your PATH.

npm install -g @anthropic-ai/claude-code

Starts an interactive session in the current directory. The folder you launch from is the project the agent can see and edit.

cd my-app && claude

Starts a session and sends the first message immediately.

claude "explain the folder structure and find the entry point"

Print mode: runs one prompt non-interactively, prints the answer, exits. The basis of every script and CI job.

claude -p "list the TODO comments in src/"

Reopens the most recent session in this directory with its full context. Short form: -c.

claude -c

Shows a picker of past sessions in this directory so you can reopen one. Short form: -r; pass a session id to skip the picker.

claude -r

Picks the model for the session. Aliases like sonnet and opus work, as do full model ids. You can also switch mid-session with /model.

claude --model opus

Grants the agent access to an extra directory outside the one you launched from, for monorepos or shared packages.

claude --add-dir ../shared-lib

Updates to the latest release, or prints the version you are on. Run update before filing a bug.

claude update

Scans the project and writes a starter CLAUDE.md with build, test and convention notes.

Empties the context window and starts fresh in the same directory. Use it between unrelated tasks.

Summarises the conversation so far to free context. Add a focus phrase to tell it what to keep.

/compact keep the failing test output and the plan

Lists every available command, including custom ones and skills.

Opens the settings UI: theme, notifications, auto-compact, model defaults.

Shows tokens used and, on API billing, the cost of the current session.

Breaks down what is filling the context window: system prompt, tools, messages, files. Newer builds; check /help.

Opens the CLAUDE.md files that apply to this session so you can edit them in place.

Switches the model for the rest of the session.

Views and edits the allow and deny rules for tools and commands.

Asks for a code review of the current changes or a pull request.

Shows the account, model, working directory and session details.

Lists connected MCP servers, their tools, and lets you authenticate remote ones.

Creates, edits and lists subagents for this project or your user account.

Views and configures hooks that run on tool events.

Restores files and conversation to an earlier checkpoint in this session. Also reachable by pressing Escape twice.

Switches to a different past session without leaving the terminal.

Toggles vim keybindings in the input box.

Configures Shift+Enter for newlines in supported terminals.

Signs in with a Claude subscription or switches accounts.

Checks the installation for problems: version, permissions, environment.

Files a bug report to Anthropic with the session context attached.

Cycles the permission mode: normal, accept edits, plan mode. Watch the label under the input box.

Interrupts the current turn. The agent stops, keeps what it already did, and waits for your next message.

Opens the message history so you can jump back to an earlier point, rewinding the conversation and, optionally, the files.

Attaches a file or directory to the message with a fuzzy picker. Cheaper than pasting the file.

@src/auth/session.ts why does this expire early?

Runs a shell command yourself and puts the output into the conversation.

!npm test

Starts a memory note; Claude asks which CLAUDE.md to save it to.

# always run pnpm, never npm

Cancels the current input or action; press twice to exit the session.

Inserts a newline for multi-line prompts. After /terminal-setup, Shift+Enter does the same.

Walks back through your previous prompts.

Reads and searches freely; asks before every file edit and every command that changes state.

Auto-approves file edits in the project; still asks before shell commands. Good for a tight loop where you review diffs after.

Read-only: the agent investigates and proposes a plan you approve before anything is edited.

claude --permission-mode plan

Skips every prompt. Only inside a sandbox or container with no secrets and nothing you cannot restore.

claude --dangerously-skip-permissions

Pre-approves or blocks specific tools for the session, with optional argument patterns.

claude --allowedTools "Read" "Bash(npm test)"

The same rules, persisted in .claude/settings.json so the whole team shares them.

{ "permissions": { "allow": ["Bash(pnpm test*)"], "deny": ["Read(./.env)"] } }

Inspects and edits the active rules without leaving the session.

Your personal instructions, loaded in every project: preferred tools, style, things you always want.

Project memory, committed to the repo and loaded every session: how to build and test, conventions, gotchas. Keep it short; point to docs instead of pasting them.

Personal notes for this project that stay out of git. Add it to .gitignore.

Imports another file into memory on load, so CLAUDE.md can pull in AGENTS.md or a conventions doc without duplicating it.

@AGENTS.md

Shared project settings: permissions, hooks, environment variables, model defaults.

Your overrides for this project; gitignored by default.

A custom slash command. The file body is the prompt; $ARGUMENTS is replaced by whatever you type after /name.

# .claude/commands/fix-issue.md
Fix GitHub issue $ARGUMENTS. Read it with gh, write a failing test, then make it pass.

A subagent: frontmatter for name, description and tools, then its system prompt.

A skill the agent loads on demand when the task matches its description. Personal skills live under ~/.claude/skills.

Project-scoped MCP servers, shared with the team through git.

The cross-tool convention read by Codex and other agents. Keep one source of truth and import it from CLAUDE.md.

Runs before a tool call. Exit code 2 blocks the call and sends your stderr to the model as the reason.

Runs after a tool call succeeds. The classic use: format the file that was just edited.

{ "matcher": "Edit|Write", "hooks": [{ "type": "command", "command": "npx prettier --write \"$FILE\"" }] }

Runs when you send a message, before the model sees it. Can add context or block the prompt.

Runs when Claude Code wants your attention, such as waiting for permission. Wire it to a desktop notification.

Runs when the agent (or a subagent) finishes a turn. Use it to require green tests before it is allowed to stop.

Runs before compaction, so you can save the transcript or inject what must survive.

Runs when a session starts or resumes. Good for loading environment context.

Filters which tool names a hook applies to; a plain name or a regex such as Edit|Write. Omit it to match everything.

Hooks receive JSON on stdin (tool name, input, session, cwd). Exit 0 allows, exit 2 blocks with feedback, anything else is a non-blocking error shown to you.

Adds a local stdio server. Everything after -- is the command that starts it.

claude mcp add github -- npx -y @modelcontextprotocol/server-github

Adds a remote HTTP server; use --transport sse for servers that still speak SSE. Authenticate with /mcp.

claude mcp add --transport http linear https://mcp.linear.app/mcp

Lists configured servers, shows one, or removes one.

claude mcp remove github

Scope: local is this folder for you only, project writes .mcp.json for the team, user applies everywhere.

claude mcp add -s project ...

How MCP tools are named once connected; use the same names in permission rules and --allowedTools.

"allow": ["mcp__github__create_issue"]

Checks server status, lists tools, and completes OAuth for remote servers.

Spawns a subagent with its own context window and reports back a summary, keeping bulk output out of your main session.

name, description (when to use it), tools (allow-list) and optionally model. The description is how Claude decides to delegate automatically.

---
name: code-reviewer
description: Reviews diffs for bugs and style. Use after any change.
tools: Read, Grep, Glob, Bash
---

Interactive UI to create and edit subagents, at project or user scope.

Explicit delegation: name the subagent in your prompt when you do not want to rely on automatic routing.

A skill folder: frontmatter name and description, then instructions and any helper files. Loaded only when relevant, so it costs no context until used.

Many skills can also be invoked by hand like a slash command.

One prompt, one answer, exit. Combine with the flags below for automation.

claude -p "summarise the last 10 commits"

Plain text (default), a single JSON result with usage and cost, or streamed JSON events for tooling.

claude -p "..." --output-format json

Caps the number of agentic turns so a runaway task cannot loop forever.

--max-turns 15

Adds instructions to the default system prompt for this run without replacing it.

--append-system-prompt "Only touch files under packages/api"

Anything piped in becomes part of the prompt context.

git diff | claude -p "review this diff for bugs"

Set ANTHROPIC_API_KEY, pick an explicit permission mode or allow-list, and let the run end in a pull request rather than a merge. Anthropic publishes an official GitHub Action.

claude -p "fix the failing test" --allowedTools "Read" "Edit" "Bash(npm test)"

Creates a second checkout of the repo on a new branch, sharing one .git. Start a separate claude session inside it.

git worktree add ../my-app-auth -b feat/auth && cd ../my-app-auth && claude

Each session gets its own files and its own branch; merge the results through pull requests.

Lists active worktrees and deletes one when the branch is merged. Worktrees cost disk; clean up.

git worktree remove ../my-app-auth

Newer builds can create an isolated worktree for a task themselves; check claude --help for the current flag.

Tokens in, tokens out, cached tokens, and the API cost so far.

What fills the window right now. If tool definitions or old files dominate, clear or compact.

Automatic: the stable prefix (system prompt, CLAUDE.md, tools) is cached between requests. Changing early context invalidates it.

Use a cheaper, faster model for grunt work and the strongest one for planning and hard bugs.

A new task in an old session starts closer to the dumb zone and pays for context it does not need.

Subscriptions meter usage in rolling windows; the API bills per token. /status shows which you are on; newer builds add a /usage view.

Anything bigger than a one-file change starts in plan mode. Correct the plan, then execute.

One outcome per message. Long multi-part prompts get the last part wrong.

Give the agent a command that proves it is done, and let it run it. Green tests beat a confident summary.

Commands, conventions, gotchas. Long docs get pointed to, not pasted; every line costs context in every session.

Start unrelated work in a fresh session so it gets the sharp part of the context window.

Read what changed before you accept it. The model is confident whether it is right or wrong.

A clean commit is the cheapest checkpoint; git resets what /rewind cannot.

Anything that must always happen (formatting, blocking rm -rf, tests before stop) goes in a hook, not a sentence.

Send codebase archaeology and log reading to a subagent so the findings, not the noise, land in your session.

Repetitive changes across many files or repos belong in claude -p with an allow-list and a PR at the end.