# Claude Code — AI Coding Agent for the Terminal

> Anthropic's official AI coding agent: interactive or scripted sessions, MCP servers, subagents, plugins, worktrees and IDE integration.

Source: https://www.jpkc.com/db/en/cheatsheets/ai-cli/claude-code/

<!-- PROSE:intro -->
Claude Code is Anthropic's official agentic coding tool: it reads, writes and runs code right in your terminal, driven by the `claude` command. By default it opens an interactive session in the current directory; with `-p`/`--print` it turns into a scriptable, pipe-friendly one-shot tool. Beyond the CLI it also runs as a desktop and web app and as an IDE extension, and it taps the latest Claude models — Fable 5 and the Claude 4.x family (Opus 4.8, Sonnet 4.6, Haiku 4.5). This cheat sheet collects the flags, subcommands and slash commands you reach for every day, from session management and permission modes to MCP servers, subagents, plugins and git worktrees.
<!-- PROSE:intro:end -->

## Basic Usage

`claude` — Start an interactive Claude Code session in the current directory.

```bash
claude
```

`claude "<prompt>"` — Start an interactive session with an initial prompt.

```bash
claude "Explain the architecture of this project"
```

`claude --version` — Show the installed Claude Code version.

```bash
claude --version
```

`claude --help` — Show all available options and commands.

```bash
claude --help
```

`claude update` — Check for updates and install the latest version if available.

```bash
claude update
```

`claude doctor` — Check the health of the Claude Code installation and auto-updater.

```bash
claude doctor
```

`claude install <target>` — Install a specific Claude Code native build (stable, latest, or version number).

```bash
claude install stable
```

`claude project` — Manage Claude Code project state.

```bash
claude project
```

`claude ultrareview [target]` — Run a cloud-hosted multi-agent code review of the current branch (or a PR number / base branch) and print the findings.

```bash
claude ultrareview 42
```

## Session Management

`claude -c` — Continue the most recent conversation in the current directory. Long: --continue

```bash
claude -c
```

`claude -r` — Open an interactive picker to resume a previous conversation. Long: --resume

```bash
claude -r
```

`claude -r <session-id>` — Resume a specific conversation directly by its session ID.

```bash
claude -r a1b2c3d4-...
```

`claude -n <name>` — Set a display name for this session (shown in /resume and terminal title).

```bash
claude -n "refactor auth module"
```

`claude --fork-session` — When resuming, create a new session ID instead of continuing the original.

```bash
claude -c --fork-session
```

`claude --session-id <uuid>` — Use a specific UUID as the session ID.

```bash
claude --session-id 00000000-0000-0000-0000-000000000001
```

`claude --from-pr <number>` — Resume a session linked to a pull request by number or URL.

```bash
claude --from-pr 42
```

## Non-Interactive Mode (--print)

`claude -p "<prompt>"` — Print the response and exit. Non-interactive for scripting and pipes.

```bash
claude -p "What does this function do?" < src/utils.js
```

`echo "<prompt>" | claude -p` — Pipe a prompt into Claude and get a single printed response.

```bash
echo "Summarize this" | claude -p
```

`cat <file> | claude -p "<prompt>"` — Pipe file contents as context into a non-interactive prompt.

```bash
cat app.py | claude -p "Find security issues"
```

`claude -p --output-format json "<prompt>"` — Output the response as a single JSON object. Formats: text, json, stream-json.

```bash
claude -p --output-format json "List 3 refactoring tips"
```

`claude -p --output-format stream-json "<prompt>"` — Stream the response as newline-delimited JSON chunks in real-time.

```bash
claude -p --output-format stream-json "Explain async/await"
```

`claude -p --json-schema '<schema>' "<prompt>"` — Validate output against a JSON Schema for structured, machine-readable responses.

```bash
claude -p --json-schema '{"type":"object","properties":{"name":{"type":"string"}}}' "Extract info"
```

`claude -p --max-budget-usd <amount> "<prompt>"` — Set a maximum spend limit in USD for this call.

```bash
claude -p --max-budget-usd 0.10 "Summarize these logs"
```

`claude -p --no-session-persistence "<prompt>"` — Don't save the session to disk (cannot be resumed).

```bash
claude -p --no-session-persistence "Quick question"
```

`claude -p --fallback-model sonnet "<prompt>"` — Automatically fall back to specified model if default is overloaded.

```bash
claude -p --fallback-model sonnet "Generate unit tests"
```

`claude -p --input-format stream-json --output-format stream-json` — Bidirectional streaming JSON for integration with custom tools or orchestrators.

```bash
claude -p --input-format stream-json --output-format stream-json
```

`claude -p --include-partial-messages ...` — Emit partial message chunks as they arrive (requires --output-format stream-json).

```bash
claude -p --output-format stream-json --include-partial-messages "Explain this"
```

`claude -p --include-hook-events ...` — Include all hook lifecycle events in the output stream (requires --output-format stream-json).

```bash
claude -p --output-format stream-json --include-hook-events "Run the build"
```

`claude -p --replay-user-messages ...` — Re-emit user messages from stdin back on stdout for acknowledgment (stream-json in+out only).

```bash
claude -p --input-format stream-json --output-format stream-json --replay-user-messages
```

`claude -p --prompt-suggestions "<prompt>"` — Emit a prompt_suggestion message after each turn predicting the next user prompt.

```bash
claude -p --prompt-suggestions "Refactor this module"
```

## Model & Effort

`claude --model opus` — Use Claude Opus (most capable). Accepts aliases: opus, sonnet, haiku.

```bash
claude --model opus
```

`claude --model sonnet` — Use Claude Sonnet (balanced speed and capability).

```bash
claude --model sonnet
```

`claude --model haiku` — Use Claude Haiku (fastest, most cost-efficient).

```bash
claude --model haiku
```

`claude --model <full-model-id>` — Use a specific model by its full ID.

```bash
claude --model claude-opus-4-8
```

`claude --effort <level>` — Set effort level: low, medium, high, xhigh, max. Higher = more thorough but slower.

```bash
claude --effort high "Perform a full security audit"
```

## Permission Modes & Tool Access

`claude --permission-mode default` — Normal mode: prompts for approval on potentially dangerous actions.

```bash
claude --permission-mode default
```

`claude --permission-mode acceptEdits` — Auto-accept all file edits without prompting.

```bash
claude --permission-mode acceptEdits
```

`claude --permission-mode plan` — Plan mode: propose changes but don't execute until approved.

```bash
claude --permission-mode plan
```

`claude --permission-mode auto` — Auto mode: classifies actions and auto-approves safe ones.

```bash
claude --permission-mode auto
```

`claude --permission-mode dontAsk` — Don't prompt for permissions; silently skip actions that would require approval instead of running them.

```bash
claude --permission-mode dontAsk
```

`claude --permission-mode bypassPermissions` — Bypass all permission checks. Only for isolated sandboxes.

```bash
claude --permission-mode bypassPermissions
```

`claude --dangerously-skip-permissions` — Bypass all permission checks (equivalent to bypassPermissions mode). Only for sandboxes with no internet access.

```bash
claude --dangerously-skip-permissions
```

`claude --allow-dangerously-skip-permissions` — Make 'bypass permissions' available as an opt-in mode without enabling it by default.

```bash
claude --allow-dangerously-skip-permissions
```

`claude --allowed-tools "<tools>"` — Restrict Claude to specific tools. Supports subcommand patterns.

```bash
claude --allowed-tools "Bash(git:*) Edit Read"
```

`claude --disallowed-tools "<tools>"` — Block specific tools while allowing all others.

```bash
claude --disallowed-tools "Bash Write"
```

`claude --tools "<tools>"` — Specify available built-in tools. Use "" to disable all, "default" for all.

```bash
claude --tools "Read,Glob,Grep"
```

`claude --add-dir <path>` — Grant tool access to additional directories beyond the current working directory.

```bash
claude --add-dir ~/shared-libs --add-dir /etc/nginx
```

## System Prompts & Agents

`claude --system-prompt "<prompt>"` — Override the default system prompt for this session.

```bash
claude --system-prompt "Reply only in German."
```

`claude --append-system-prompt "<prompt>"` — Append instructions to the default system prompt without replacing it.

```bash
claude --append-system-prompt "Always use Bootstrap 5."
```

`claude --system-prompt-file <path>` — Load the system prompt override from a file instead of an inline string.

```bash
claude --system-prompt-file ./prompts/reviewer.md
```

`claude --append-system-prompt-file <path>` — Append a system prompt loaded from a file to the default system prompt.

```bash
claude --append-system-prompt-file ./prompts/house-rules.md
```

`claude --brief` — Enable the SendUserMessage tool so an agent can send messages back to the user.

```bash
claude --brief
```

`claude --agent <agent-name>` — Use a named agent configured in settings.

```bash
claude --agent reviewer
```

`claude agents` — List all configured agents from user, project, and local settings.

```bash
claude agents
```

`claude --agents '<json>'` — Define inline agents as JSON for the current session.

```bash
claude --agents '{"tester":{"description":"Writes tests","prompt":"Write unit tests only"}}'
```

`claude --bare` — Minimal mode: skip hooks, LSP, plugins, auto-memory, CLAUDE.md discovery.

```bash
claude --bare -p "Quick question"
```

## Interactive Slash Commands: Session

`/help` — Show help and available commands.

```bash
/help
```

`/clear` — Clear conversation history and free up context. Aliases: /reset, /new

```bash
/clear
```

`/compact [instructions]` — Compact conversation to save context, with optional focus instructions.

```bash
/compact focus on the auth module changes
```

`/context` — Visualize current context usage as a colored grid.

```bash
/context
```

`/resume [session]` — Resume a conversation by ID or name. Alias: /continue

```bash
/resume
```

`/branch [name]` — Create a branch of the current conversation at this point. Alias: /fork

```bash
/branch experiment-1
```

`/rename [name]` — Rename the current session.

```bash
/rename auth-refactor
```

`/export [filename]` — Export the current conversation as plain text.

```bash
/export conversation.txt
```

`/exit` — Exit the CLI. Alias: /quit

```bash
/exit
```

## Interactive Slash Commands: Model & Tools

`/model [model]` — Select or change the AI model mid-session.

```bash
/model opus
```

`/effort [level]` — Set effort level: low, medium, high, xhigh, max, auto.

```bash
/effort high
```

`/fast [on|off]` — Toggle fast mode (same model, faster output).

```bash
/fast on
```

`/cost` — Show token usage statistics for the current session.

```bash
/cost
```

`/usage` — Show plan usage limits and rate limit status.

```bash
/usage
```

`/permissions` — View or update permissions. Alias: /allowed-tools

```bash
/permissions
```

`/tasks` — List and manage background tasks.

```bash
/tasks
```

## Interactive Slash Commands: Code & Git

`/diff` — Open interactive diff viewer showing uncommitted changes.

```bash
/diff
```

`/rewind` — Rewind conversation and code to a previous point. Alias: /checkpoint

```bash
/rewind
```

`/pr-comments [PR]` — Fetch and display comments from a GitHub pull request.

```bash
/pr-comments 42
```

`/security-review` — Analyze pending changes on current branch for security vulnerabilities.

```bash
/security-review
```

`/copy [N]` — Copy the last (or Nth-latest) assistant response to clipboard.

```bash
/copy
```

`/btw <question>` — Ask a quick side question without adding to conversation context.

```bash
/btw what's the syntax for a ternary in PHP?
```

## Interactive Slash Commands: Configuration

`/config` — Open settings interface (theme, model, output style). Alias: /settings

```bash
/config
```

`/status` — Show version, model, account, and connectivity status.

```bash
/status
```

`/theme` — Change color theme (light/dark, colorblind-accessible, ANSI).

```bash
/theme
```

`/color [color]` — Set the prompt bar color (red, blue, green, yellow, purple, etc.).

```bash
/color blue
```

`/vim` — Toggle between Vim and Normal editing modes.

```bash
/vim
```

`/voice` — Toggle push-to-talk voice dictation.

```bash
/voice
```

`/keybindings` — Open or create keybindings configuration file.

```bash
/keybindings
```

`/terminal-setup` — Configure terminal keybindings for Shift+Enter and other shortcuts.

```bash
/terminal-setup
```

`/statusline` — Configure Claude Code's status line (or auto-configure from shell prompt).

```bash
/statusline
```

`/memory` — Edit CLAUDE.md, enable/disable auto-memory, view auto-memory entries.

```bash
/memory
```

`/init` — Initialize project with CLAUDE.md guide.

```bash
/init
```

`/hooks` — View hook configurations for tool events.

```bash
/hooks
```

`/add-dir <path>` — Add a new working directory to the current session.

```bash
/add-dir ~/other-project
```

## Interactive Slash Commands: Integrations

`/mcp` — Manage MCP server connections and OAuth authentication.

```bash
/mcp
```

`/ide` — Manage IDE integrations (VS Code, JetBrains) and show status.

```bash
/ide
```

`/chrome` — Configure Claude in Chrome integration.

```bash
/chrome
```

`/plugin` — Manage Claude Code plugins.

```bash
/plugin
```

`/skills` — List available skills (custom slash commands).

```bash
/skills
```

`/agents` — Manage agent configurations.

```bash
/agents
```

`/plan [description]` — Enter plan mode directly from the prompt.

```bash
/plan refactor the authentication module
```

`/schedule [description]` — Create, update, list, or run cloud scheduled tasks (triggers).

```bash
/schedule
```

## Interactive Slash Commands: Account & Info

`/login` — Sign in to your Anthropic account.

```bash
/login
```

`/logout` — Sign out from your Anthropic account.

```bash
/logout
```

`/doctor` — Diagnose and verify Claude Code installation and settings.

```bash
/doctor
```

`/stats` — Visualize daily usage, session history, streaks, and model preferences.

```bash
/stats
```

`/insights` — Generate a report analyzing your Claude Code sessions.

```bash
/insights
```

`/release-notes` — View the full changelog with recent versions first.

```bash
/release-notes
```

`/feedback [report]` — Submit feedback about Claude Code. Alias: /bug

```bash
/feedback
```

`/desktop` — Continue current session in Claude Code Desktop app. Alias: /app

```bash
/desktop
```

`/mobile` — Show QR code to download Claude mobile app. Aliases: /ios, /android

```bash
/mobile
```

`/remote-control` — Make session available for remote control from claude.ai. Alias: /rc

```bash
/remote-control
```

`/install-github-app` — Set up Claude GitHub Actions app for a repository.

```bash
/install-github-app
```

`/extra-usage` — Configure extra usage to keep working when rate limits hit.

```bash
/extra-usage
```

## MCP Servers

`claude mcp list` — List all configured MCP (Model Context Protocol) servers.

```bash
claude mcp list
```

`claude mcp add <name> -- <command> [args...]` — Add a stdio MCP server as a subprocess.

```bash
claude mcp add my-server -- npx my-mcp-server --port 3000
```

`claude mcp add --transport http <name> <url>` — Add an HTTP/SSE MCP server by URL.

```bash
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
```

`claude mcp add -e <KEY>=<val> <name> -- <command>` — Add a stdio MCP server with environment variables.

```bash
claude mcp add -e GITHUB_TOKEN=ghp_xxx github -- npx @modelcontextprotocol/server-github
```

`claude mcp add --transport http <name> <url> --header "Authorization: Bearer <token>"` — Add an HTTP MCP server with a custom auth header.

```bash
claude mcp add --transport http api https://api.example.com/mcp --header "Authorization: Bearer xxx"
```

`claude mcp add-json <name> '<json>'` — Add an MCP server with a full JSON config string.

```bash
claude mcp add-json myserver '{"type":"stdio","command":"npx","args":["my-server"]}'
```

`claude mcp get <name>` — Show full configuration details of a specific MCP server.

```bash
claude mcp get sentry
```

`claude mcp remove <name>` — Remove a configured MCP server.

```bash
claude mcp remove my-server
```

`claude mcp add-from-claude-desktop` — Import MCP servers from the Claude Desktop app (Mac and WSL only).

```bash
claude mcp add-from-claude-desktop
```

`claude mcp serve` — Start Claude Code itself as an MCP server (for integration with other tools).

```bash
claude mcp serve
```

`claude --mcp-config <path>` — Load additional MCP servers from a JSON config file for this session.

```bash
claude --mcp-config ~/.config/mcp-servers.json
```

`claude --strict-mcp-config --mcp-config <path>` — Only use MCP servers from the specified config, ignore all others.

```bash
claude --strict-mcp-config --mcp-config config.json
```

`claude mcp reset-project-choices` — Reset all approved/rejected project-scoped MCP server choices.

```bash
claude mcp reset-project-choices
```

## Authentication

`claude auth login` — Sign in to your Anthropic account (opens browser for OAuth).

```bash
claude auth login
```

`claude auth logout` — Log out from the current Anthropic account.

```bash
claude auth logout
```

`claude auth status` — Show the current authentication status and active account.

```bash
claude auth status
```

`claude setup-token` — Set up a long-lived authentication token (requires Claude subscription).

```bash
claude setup-token
```

## Worktrees & IDE

`claude -w` — Create a new git worktree for this session (isolated branch). Long: --worktree

```bash
claude -w
```

`claude -w <name>` — Create a named git worktree.

```bash
claude -w feature-refactor
```

`claude -w --tmux` — Create a worktree and open it in a new tmux session (iTerm2 native panes when available; --tmux=classic forces traditional tmux).

```bash
claude -w --tmux
```

`claude --ide` — Auto-connect to an open IDE (VS Code, JetBrains) on startup.

```bash
claude --ide
```

`claude --remote-control [name]` — Start an interactive session with Remote Control enabled (optionally named) for control from claude.ai.

```bash
claude --remote-control "laptop session"
```

## Plugins

`claude plugin list` — List all installed plugins.

```bash
claude plugin list
```

`claude plugin install <plugin>` — Install a plugin from the marketplace.

```bash
claude plugin install my-plugin
```

`claude plugin enable <plugin>` — Enable a previously disabled plugin.

```bash
claude plugin enable my-plugin
```

`claude plugin disable <plugin>` — Disable an installed plugin without removing it.

```bash
claude plugin disable my-plugin
```

`claude plugin update <plugin>` — Update a plugin to the latest version (restart required).

```bash
claude plugin update my-plugin
```

`claude plugin uninstall <plugin>` — Uninstall a plugin completely.

```bash
claude plugin uninstall my-plugin
```

`claude plugin validate <path>` — Validate a local plugin or marketplace manifest.

```bash
claude plugin validate ./my-plugin/
```

`claude --plugin-dir <path>` — Load a local plugin directory or .zip for this session only (repeatable).

```bash
claude --plugin-dir ./my-plugin/ --plugin-dir ./other.zip
```

`claude --plugin-url <url>` — Fetch a plugin .zip from a URL for this session only (repeatable).

```bash
claude --plugin-url https://example.com/my-plugin.zip
```

## Auto Mode

`claude auto-mode config` — Print the effective auto mode config as JSON.

```bash
claude auto-mode config
```

`claude auto-mode defaults` — Print the default auto mode allow/deny rules as JSON.

```bash
claude auto-mode defaults
```

`claude auto-mode critique` — Get AI feedback on your custom auto mode rules.

```bash
claude auto-mode critique
```

## Debugging & Diagnostics

`claude --debug` — Enable debug mode: verbose logs, tool calls, API requests.

```bash
claude --debug
```

`claude --debug <filter>` — Filter debug output by category. Prefix with ! to exclude.

```bash
claude --debug api,hooks
```

`claude --debug-file <path>` — Write debug logs to a file (implicitly enables debug mode).

```bash
claude --debug-file /tmp/claude-debug.log
```

`claude --verbose` — Enable verbose output mode.

```bash
claude --verbose
```

## Scripting & Automation

`git diff HEAD~1 | claude -p "Summarize these changes"` — Pipe git diff into Claude to generate a commit message.

```bash
git diff HEAD~1 | claude -p "Write a conventional commit message"
```

`claude -p --output-format json "<prompt>" | jq '.result'` — Pipe JSON output to jq for processing in shell scripts.

```bash
claude -p --output-format json "Extract function names" | jq '.result'
```

`claude --settings '<json>'` — Load settings from a JSON file path or inline JSON string.

```bash
claude --settings '{"model":"sonnet","verbose":true}'
```

`claude --setting-sources <sources>` — Control which setting sources are loaded: user, project, local.

```bash
claude --setting-sources user,project
```

`claude -p --betas <feature> "<prompt>"` — Enable a beta feature via header (API key users only).

```bash
claude -p --betas interleaved-thinking-2025-05-14 "Think step by step"
```

`claude --disable-slash-commands` — Disable all slash command skills for this session.

```bash
claude --disable-slash-commands
```

`claude --chrome` — Enable Claude in Chrome integration for this session.

```bash
claude --chrome
```

`claude --no-chrome` — Disable the Claude in Chrome integration for this session.

```bash
claude --no-chrome
```

`claude --file <file_id:path>` — Download file resources at startup. Format: file_id:relative_path (repeatable).

```bash
claude --file file_abc:doc.txt --file file_def:img.png
```

`claude --exclude-dynamic-system-prompt-sections` — Move per-machine sections (cwd, env, memory paths, git status) into the first user message for better cross-user prompt-cache reuse.

```bash
claude --exclude-dynamic-system-prompt-sections -p "Review"
```

## Environment Variables

`CLAUDE_CONFIG_DIR=<path> claude` — Use a custom config directory instead of the default ~/.claude. Enables separate configs for different projects or contexts.

```bash
CLAUDE_CONFIG_DIR=~/.claude-work claude
```

`alias claude-<name>="CLAUDE_CONFIG_DIR=~/.<dir> claude"` — Create shell aliases for different Claude configurations (add to .bashrc/.zshrc).

```bash
alias claude-private="CLAUDE_CONFIG_DIR=~/.claude-private claude"
alias claude-work="CLAUDE_CONFIG_DIR=~/.claude-work claude"
```

`ANTHROPIC_API_KEY=<key> claude` — Set the API key directly instead of using OAuth login.

```bash
ANTHROPIC_API_KEY=sk-ant-xxx claude -p "Hello"
```

`CLAUDE_MODEL=<model> claude` — Set the default model without using --model flag.

```bash
CLAUDE_MODEL=claude-sonnet-4-6 claude
```

`CLAUDE_CODE_SIMPLE=1 claude` — Simplified mode (same as --bare): skip hooks, LSP, plugins, auto-memory.

```bash
CLAUDE_CODE_SIMPLE=1 claude -p "Quick question"
```

`ANTHROPIC_BASE_URL=<url> claude` — Use a custom API endpoint (proxy or compatible provider).

```bash
ANTHROPIC_BASE_URL=https://my-proxy.example.com claude
```

`DISABLE_AUTOUPDATE=1 claude` — Disable the automatic update check on startup.

```bash
DISABLE_AUTOUPDATE=1 claude
```

`CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1` — Always reset the Bash tool's working directory to the project root between commands.

```bash
CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1 claude
```

## Useful Aliases & Tips

`alias claude-private="CLAUDE_CONFIG_DIR=~/.claude-private claude"` — Separate config for creative/personal projects — own settings, memory, and MCP servers.

```bash
# In ~/.bashrc or ~/.zshrc:
alias claude-private="CLAUDE_CONFIG_DIR=~/.claude-private claude"
```

`alias claude-work="CLAUDE_CONFIG_DIR=~/.claude-work claude"` — Separate config for work projects — own API key, permissions, and agents.

```bash
# In ~/.bashrc or ~/.zshrc:
alias claude-work="CLAUDE_CONFIG_DIR=~/.claude-work claude"
```

`alias cq='claude -p'` — Quick alias for non-interactive one-shot queries.

```bash
cq "What's the regex for an email address?"
```

`alias cr='claude -c'` — Quick alias to continue the last conversation.

```bash
cr
```

`alias claude-review='claude -p --model opus "Review this code for bugs and security issues"'` — Predefined alias for code review with a specific model.

```bash
cat src/auth.py | claude-review
```

`ccommit() { git diff --cached | claude -p "Write a conventional commit message for these staged changes"; }` — Shell function to generate commit messages from staged changes.

```bash
git add -p && ccommit
```

`cexplain() { cat "$1" | claude -p "Explain this file concisely"; }` — Shell function to quickly explain any file.

```bash
cexplain src/config.ts
```

## Keyboard Shortcuts (interactive session)

`Enter` — Submit the current prompt (configurable in /keybindings).

```bash
Type your prompt and press Enter to send
```

`Shift+Enter` — Insert a newline without submitting (requires /terminal-setup).

```bash
Write multi-line prompts with Shift+Enter
```

`Ctrl+C` — Cancel the current operation or generation.

```bash
Press Ctrl+C to stop a long response
```

`Escape` — Cancel or go back in menus and pickers.

```bash
Press Escape to close the session picker
```

`Up / Down Arrow` — Navigate through prompt history.

```bash
Press Up to recall previous prompts
```

`/` — Open slash command autocomplete. Type to filter.

```bash
Type / to see all available commands
```

<!-- PROSE:outro -->
## Conclusion

Claude Code rewards a deliberate setup: pin sensitive operations behind permission modes, reserve `--dangerously-skip-permissions` for throwaway sandboxes only, and lean on `-p` plus `--output-format json` when you wire it into scripts and CI. Once you have a feel for sessions, agents and MCP servers, the same binary scales from a quick one-off question to a long-running, multi-step refactor. Treat the flags here as a starting point and check the official docs for new commands between releases.

## Further Reading

- [Claude Code documentation](https://docs.claude.com/en/docs/claude-code/overview) – Anthropic's official guide to installation, configuration, slash commands, hooks and MCP
- [anthropics/claude-code on GitHub](https://github.com/anthropics/claude-code) – issue tracker, release notes and reference material
<!-- PROSE:outro:end -->