← All cheat sheets

Claude Code

Getting Started

Installation {.row-span-2}

macOS / Linux / WSL

$ curl -fsSL https://claude.ai/install.sh | bash

Windows PowerShell

> irm https://claude.ai/install.ps1 | iex

Homebrew (macOS)

$ brew install --cask claude-code

WinGet (Windows)

> winget install Anthropic.ClaudeCode

Native install auto-updates. Homebrew/WinGet require brew upgrade claude-code or winget upgrade Anthropic.ClaudeCode to update.

Windows requires Git for Windows.

First Session

$ cd your-project
$ claude

• Log in on first run (Claude Pro / Max / Team / Enterprise or Anthropic Console)
• Type /help for all commands
• Type /resume to continue a prior conversation
• Press ? to see keyboard shortcuts
• Type exit or press Ctrl+D to quit

Key Concepts {.secondary}

{.bold-first}

Common Prompts

• what does this project do?
• find the bug causing the login error
• write unit tests for the auth module
• refactor this to use async/await
• commit my changes with a descriptive message
• create a PR and describe my changes
• review my changes for security issues
• add input validation to the signup form

{.cols-2 .marker-none}

CLI Commands {.cols-2}

Session Commands {.row-span-3}

{.show-header}

Auth Commands

MCP Commands

Plugin Commands

Pipe Examples

# Explain a build error
$ cat error.log | claude -p "explain the root cause"

# Review changed files
$ git diff main --name-only | claude -p "review for issues"

# Analyze logs
$ tail -200 app.log | claude -p "summarize anomalies"

# Save output to file
$ cat data.txt | claude -p "summarize this" > summary.txt

Unix Integration

Add Claude as a linter in package.json:

{
  "scripts": {
    "lint:ai": "claude -p 'review changes vs main, report file:line + issue'"
  }
}

Use --output-format for structured output:

$ claude -p "analyze for bugs" --output-format json

CLI Flags {.cols-3}

Session & Mode {.row-span-2}

{.bold-first}

Output & Format

{.bold-first}

Tools & Access

{.bold-first}

System Prompt Flags

{.bold-first}

Prefer --append-* to preserve Claude's built-in capabilities. Use --system-prompt only when full control is needed.

Slash Commands {.cols-3}

Session & Context {.row-span-2}

{.show-header}

Code & Git

Settings & Config

Display & UI

Help & System

Keyboard Shortcuts {.cols-3}

General Controls {.row-span-2}

{.shortcuts}

Text Editing

{.shortcuts}

Vim Mode

Enable with /vim or in /config. Esc → NORMAL, i/a/o → INSERT.

Multiline & Input

macOS: set Option as Meta in terminal prefs for Alt+* shortcuts to work.

Permission Modes {.cols-3}

Modes Overview {.col-span-2 .row-span-2}

{.show-header}

Regardless of mode, writes to .git, .vscode, .idea, .husky, and .claude always prompt (except .claude/commands, .claude/agents, .claude/skills).

Configure Default Mode

{
  "permissions": {
    "defaultMode": "acceptEdits"
  }
}

Auto Mode Notes

Requires Team / Enterprise / API plan + Claude Sonnet 4.6 or Opus 4.6. A separate classifier reviews each action before it runs and blocks actions that escalate beyond your intent. Enable at startup:

$ claude --enable-auto-mode

Switch Modes

During a session:

Press Shift+Tab to cycle:

default → acceptEdits → plan → (auto)

At startup:

$ claude --permission-mode plan
$ claude --permission-mode acceptEdits

Bypass all (containers only): {.primary}

$ claude --dangerously-skip-permissions

Permission Rules

Layer allow / deny rules on top of any mode in .claude/settings.json:

{
  "permissions": {
    "allow": ["Bash(npm test)", "Bash(git log *)"],
    "deny": ["Bash(rm -rf *)"]
  }
}

View and edit rules with /permissions.

Memory & CLAUDE.md {.cols-3}

CLAUDE.md Locations {.col-span-2 .row-span-2}

{.show-header}

Files in parent directories load at launch. Subdirectory files load on demand when Claude reads files there. More specific scope wins on conflict.

Write Effective Instructions

• Size: keep each file under 200 lines — longer files reduce adherence
• Specific: "Use 2-space indentation" not "format code nicely"
• Structured: use markdown headers to group related rules
• Consistent: avoid conflicting instructions across files

Run /init to auto-generate a CLAUDE.md from your codebase. Set CLAUDE_CODE_NEW_INIT=1 for an interactive multi-phase flow that also sets up skills and hooks.

Organize with .claude/rules/

.claude/
├── CLAUDE.md
└── rules/
    ├── code-style.md   # style guidelines
    ├── testing.md      # test conventions
    └── security.md     # security requirements

Path-scoped Rules

---
paths:
  - 'src/api/**/*.ts'
  - 'tests/**/*.test.ts'
---
# API Rules
All endpoints must include input validation.

Rules without paths load every session. Rules with paths load only when matching files are opened.

Auto Memory

Claude saves its own notes in:

~/.claude/projects/<project>/memory/
├── MEMORY.md          # index (first 200 lines loaded)
├── debugging.md       # topic files (loaded on demand)
└── api-conventions.md

• On by default; toggle in /memory or set autoMemoryEnabled: false
• Persists across sessions and worktrees in the same git repo
• Machine-local — not shared across machines

Disable via env:

$ export CLAUDE_CODE_DISABLE_AUTO_MEMORY=1

Import Syntax

Reference other files from CLAUDE.md:

See @README.md for project overview.
Build commands: @package.json

# Workflows

@docs/git-workflow.md

• Both relative and absolute paths are supported
• Max import depth: 5 hops
• Imported files are expanded at session start
• HTML comments in CLAUDE.md are stripped from context

Hooks {.cols-2}

Hook Events {.row-span-2}

{.show-header}

Exit codes: 0 = success (JSON decision), 2 = block action (stderr to model), other = non-blocking error.

Use $CLAUDE_PROJECT_DIR to reference hook scripts relative to the project root.

Hook Types

{.bold-first}

Auto-format After File Edits

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint --silent"
          }
        ]
      }
    ]
  }
}

Notify When Claude Needs You (macOS)

{
  "hooks": {
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "osascript -e 'display notification \"Claude needs attention\" with title \"Claude Code\"'"
          }
        ]
      }
    ]
  }
}

Config in ~/.claude/settings.json (user) or .claude/settings.json (project). View hooks with /hooks.

MCP Servers {.cols-2}

Add MCP Server {.row-span-2}

Stdio server (local process)

$ claude mcp add my-server -- npx my-mcp-server

With environment variables

$ claude mcp add -e KEY=val my-server -- npx server

HTTP server

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

HTTP with auth header

$ claude mcp add --transport http my-api https://api.example.com/mcp --header "Authorization: Bearer $TOKEN"

JSON format

$ claude mcp add-json my-server '{"command":"npx","args":["my-mcp"]}'

Import from Claude Desktop

$ claude mcp add-from-claude-desktop

Manage servers

$ claude mcp list           # list all servers
$ claude mcp get <name>     # show server details
$ claude mcp remove <name>  # remove a server

Config stored in ~/.claude/settings.json (user) or .claude/settings.json (project).

MCP in Session

Reference MCP resources with @:

@github:repos/owner/repo/issues
@memory:entities
@filesystem:/path/to/file

Run MCP prompts as slash commands:

/mcp__github__search_repositories
/mcp__memory__create_entities

MCP tool pattern: mcp__<server>__<tool>

Manage in session:

/mcp

Hook on MCP tools:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "mcp__memory__.*",
        "hooks": [{ "type": "command", "command": "logger.sh" }]
      }
    ]
  }
}

Worktrees & Agents {.cols-2}

Git Worktrees {.row-span-2}

Run parallel sessions in isolated branches:

# Create worktree and start Claude
$ claude --worktree feature-auth
$ claude -w bugfix-123

# Auto-generated name
$ claude --worktree

Worktrees are created at .claude/worktrees/<name>/ and branch from origin/HEAD.

Auto-cleanup: no changes → removed on exit. With changes → Claude prompts to keep or remove.

Add to .gitignore:

.claude/worktrees/

Copy secrets to worktrees

Create .worktreeinclude in project root:

.env
.env.local
config/secrets.json

Manual worktree commands

# Create with specific branch
$ git worktree add ../project-feat -b feat

# List all worktrees
$ git worktree list

# Remove when done
$ git worktree remove ../project-feat

Re-sync origin HEAD after remote branch change:

$ git remote set-head origin -a

Subagents

Create in .claude/agents/<name>.md:

---
name: code-reviewer
description: Reviews code for bugs and style
tools:
  - Read
  - Grep
  - Glob
---
You are an expert code reviewer.
Focus on correctness and clarity.

Use subagents naturally in conversation:

• review the auth module for security issues
• use the code-reviewer agent on api.ts
• /agents — manage agent configs

Subagent with worktree isolation:

---
name: parallel-worker
isolation: worktree
description: Works in isolated branch
---

Shared auto memory for subagents — add to frontmatter:

autoMemoryEnabled: true

Headless & Scripting {.cols-2}

Non-interactive Mode {.row-span-2}

Run Claude programmatically with -p / --print:

# Basic one-off query
$ claude -p "what does this file do?"

# Stream JSON (real-time events)
$ claude -p "query" --output-format stream-json

# JSON with full metadata
$ claude -p "query" --output-format json

# Limit turns and cost
$ claude -p "query" --max-turns 5 --max-budget-usd 1.00

# Validated structured output
$ claude -p "query" --json-schema '{"type":"object"}'

Resume in headless mode

# Continue most recent session
$ claude -c -p "follow-up question"

# Resume named session
$ claude -r my-session -p "continue the task"

Output formats

{.bold-first}

Bare mode (faster startup)

$ claude --bare -p "query"

Skips hooks, CLAUDE.md auto-discovery, plugins, MCP, and auto memory. Sets CLAUDE_CODE_SIMPLE=1. Ideal for scripting.

Session persistence

# Don't save session to disk
$ claude -p "query" --no-session-persistence

Scheduling

Create a cloud scheduled task:

/schedule review open PRs every morning at 9am

Session-scoped loop (stays open):

/loop 5m check for new issues

GitHub Actions

- uses: anthropics/claude-code-action@beta
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    prompt: 'review this PR for issues and comment'

GitLab CI/CD

claude-review:
  script:
    - claude -p "review changes in this MR"
      --output-format json

Also see {.cols-1}

• Claude Code Docs (code.claude.com)
• CLI Reference (code.claude.com)
• All Slash Commands (code.claude.com)
• Hooks Reference (code.claude.com)
• MCP Documentation (code.claude.com)
• Memory & CLAUDE.md (code.claude.com)
• Permission Modes (code.claude.com)
• GitHub Repository (github.com)
• Community Discord (anthropic.com)