Quick Reference

Show available commands and usage hints.

Start a fresh conversation. CLAUDE.md instructions stay active.

Summarize conversation to reduce context usage. Accepts focus instructions.

Show context window usage with a visual breakdown of token allocation.

Open an interactive viewer for uncommitted changes.

Switch between Sonnet, Opus, and Haiku mid-session.

Show session token usage and estimated cost.

Show current version, model, and account info.

Run a health check on your Claude Code installation.

Scan your project and generate a starter CLAUDE.md.

View and edit CLAUDE.md memory files (global, project, auto).

Review code changes on the current branch with suggestions.

View and manage tool permissions. Configure in .claude/settings.json.

Open Claude Code configuration and settings.

Switch Anthropic accounts.

Fork conversation into a parallel branch to explore alternatives.

Roll back to a previous message and undo file changes after that point.

Resume a previously saved session by name or ID.

Rename the current session for easier recall later.

Export the conversation to a markdown file.

Set reasoning depth: low, medium, high, or max.

Enter planning mode — Claude researches first, then presents a plan for approval.

Ask a side question without adding it to conversation history.

Split work across parallel agents in isolated git worktrees.

Run a task on a recurring interval within your session.

Create a cloud-backed scheduled task that runs even when offline.

Toggle verbose mode to see tool calls and thinking steps. Also Ctrl+O.

Review recently changed files for code quality, reuse, and efficiency.

List, create, edit, or remove subagent definitions.

Show active MCP server connections and available tools.

Manage plugins — install, list, remove, or reload.

Hot-reload all plugin files during development.

Enable OS-level isolation for file system and network access.

Cycle through permission modes: default → plan → acceptEdits → auto.

Toggle extended thinking on or off.

Cancel the current operation or stop a running command.

Exit Claude Code from the terminal.

Background a currently running subagent task.

Toggle verbose/debug mode (same as /debug).

Open the current plan in an external editor.

Open site search on claude.nagdy.me.

Dismiss the active dialog or current suggestion.

Run a one-shot prompt non-interactively. Foundation for CI/CD integration.

Return structured JSON output. Useful for parsing in scripts and pipelines.

Override the default model for a single invocation.

Set permission mode: default, plan, acceptEdits, auto, or bypassPermissions.

Enable OS-level isolation for safe automated analysis.

Cap execution to n turns. Useful for time-limiting automated runs.

Don't save session data. Good for disposable automation tasks.

Resume the most recent Claude Code session.

Continue a paused workflow from the current repository.

Start a session with a specific subagent.

Load a plugin for this session only (for testing).

Cleanest output for scripted usage. No formatting or decoration.

Run in an isolated git worktree for experimental work.

Project-level instructions, conventions, and workflow notes. Committed to git and shared with the team.

Personal overrides for CLAUDE.md. Git-ignored, not shared.

Project settings: permissions, hooks, MCP servers. Committed to git.

Personal project settings. Git-ignored, overrides .claude/settings.json.

Global user instructions that apply to all projects.

Global user settings that apply to all projects.

Project-scoped custom skills (SKILL.md files). Committed to git.

Project-scoped subagent definitions. Committed to git.

Path-scoped rules. Use frontmatter paths: field to target specific files.

Project MCP server configuration. Committed to git, shared with team.

User/local MCP server configuration.

Register a new MCP server. Supports HTTP and stdio transports.

Add an MCP server with authentication headers.

List all configured MCP servers with transport and connection status.

Show details for a specific MCP server.

Remove an MCP server configuration.

Import MCP server configurations from Claude Desktop.

Show active connections in-session and trigger OAuth flows.

MCP tools appear namespaced. Use naturally in conversation.

Runs before a tool executes. Can block the action (exit code 2).

Runs after a tool completes. Use for formatting, linting, or logging.

Intercept user input before Claude processes it.

Runs when Claude finishes responding. Check completion criteria.

Track subagent lifecycle for orchestration and logging.

command (shell), prompt (LLM evaluation), agent (subagent), http (webhook).

Filter which tools trigger hooks: exact name, regex, or * for all.

Define hooks in SKILL.md frontmatter. Scoped to that skill only.

Ask before write/edit/bash operations. Read, Glob, Grep always allowed.

Research and present plans only. No file modifications until approved.

Allow file edits without prompting. Still ask for Bash commands.

Allow all operations without prompting. Use in trusted environments.

Skip all safety checks. Only for fully automated CI/CD pipelines.

Pre-approve specific tools in .claude/settings.json.

Block dangerous operations regardless of permission mode.

Invoke a specific agent inline during conversation.

Start a full session with a specific agent from the CLI.

Define project-scoped agents with frontmatter for tools, model, effort.

general-purpose, Explore (Haiku, read-only), Plan (research first).

Run agent in an isolated git worktree for safe experimentation.

Run agent in background. Use Ctrl+B to background a running agent.

Install a plugin from the official marketplace.

Install a plugin directly from a GitHub repository.

List installed plugins with their skills, agents, and hooks.

Hot-reload plugin files during development.

Load a plugin for one session only (for testing).

Required plugin manifest. Declares name, version, author, userConfig.

Plugin commands are namespaced to avoid conflicts.

Deep work: set high reasoning, plan first, then execute.

End-of-session: review changes, check cost, export, then compact.

Large refactors: split work across parallel agents in isolated worktrees.

Monitoring: poll build status, error logs, or deploy health on interval.

Exploration: branch conversation, try an approach, resume if it fails.

CI/CD: pipe diffs into Claude for automated code review with JSON output.

Project setup: generate instructions, customize, share with team.