The complete reference for Claude Code, Anthropic's agentic coding CLI. Every command, keyboard shortcut, CLI flag, configuration option, and workflow pattern in one place. Tested and verified on Claude Code's latest release.

Full article with screenshots and extended examples: computingforgeeks.com/claude-code-cheat-sheet

• Installation
• Keyboard Shortcuts
• Slash Commands
• CLI Flags
• CLAUDE.md - Project Instructions
• Permission Modes
• Models and Effort Levels
• MCP Servers
• Custom Skills
• Custom Subagents
• Hooks - Automation Triggers
• Context Window Management
• Git Worktrees
• Settings File Reference
• Environment Variables
• File Structure Reference
• Practical Workflow Tips
• Prompting Tips
• Token Saving Strategies
• Diagnostics
• IDE Integrations
• Auto Mode
• Automation Scripts
• Quick Reference Card
• Subcommands Reference

Install Claude Code on macOS, Linux, or Windows (WSL):

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

On macOS via Homebrew:

brew install --cask claude-code

On Windows (PowerShell):

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

Verify and authenticate:

claude --version
claude auth login

These work inside the interactive Claude Code terminal.

# Start interactive session
claude

# Start with initial prompt
claude "refactor the auth module"

# Continue most recent session
claude -c

# Resume specific session by name
claude -r "auth-refactor"

# Name a session for later
claude -n "feature-payments"

# Run in isolated git worktree
claude -w feature-branch

# Run in worktree with tmux panes
claude -w feature-branch --tmux

# Resume session linked to a GitHub PR
claude --from-pr 42

# Fork a session (new ID, keeps context)
claude -c --fork-session

# Enable auto mode (AI decides permissions)
claude --permission-mode auto

# Bare mode (skip hooks, plugins, auto-memory)
claude --bare

The -p flag runs Claude Code non-interactively. It processes the prompt and exits. This is the key to integrating Claude Code into scripts, CI/CD pipelines, and Unix pipes:

# Simple query
claude -p "explain this error in server.log"

# Pipe input
cat error.log | claude -p "what caused this crash?"

# Git diff review
git diff main | claude -p "review for security issues"

# JSON output for scripting
claude -p "list all TODO comments" --output-format json

# Structured output with schema validation
claude -p "extract function names from auth.py" \
  --output-format json \
  --json-schema '{"type":"object","properties":{"functions":{"type":"array","items":{"type":"string"}}}}'

# Auto-approve tools (careful with this)
claude -p "run tests and fix failures" --allowedTools "Bash,Read,Edit"

# Set spending limit
claude -p "refactor the API layer" --max-budget-usd 5.00

# Limit turns
claude -p "fix the bug" --max-turns 3

# Fallback model when primary is overloaded
claude -p "review this code" --fallback-model haiku

# Restrict available tools
claude -p "analyze this" --tools "Read,Grep,Glob"

# Block specific tools (deny list)
claude -p "refactor auth module" --disallowedTools "Bash(rm:*),Bash(sudo:*)"

# Override system prompt entirely
claude -p "review this code" --system-prompt "You are a security auditor. Focus only on vulnerabilities."

# Append to default system prompt
claude -p "explain this function" --append-system-prompt "Always include time complexity analysis."

# Load MCP servers from external config file
claude -p "check open issues" --mcp-config ./ci-mcp.json

# Disable session persistence (ephemeral, for CI/CD)
claude -p "run lint check" --no-session-persistence

# Debug mode (logs API calls, tool usage, timings)
claude -p "fix the build" --debug

# Debug with category filter
claude -p "fix the build" --debug "api,hooks"

# Write debug output to a file
claude -p "fix the build" --debug-file /tmp/claude-debug.log

# Select a specific agent
claude -p "review auth.py" --agent code-reviewer

# Enable Chrome debugging integration
claude --chrome

# Use specific model
claude --model opus
claude --model sonnet
claude --model haiku

# Set reasoning effort
claude --effort high    # More thorough (costs more)
claude --effort low     # Faster, cheaper

# Custom system prompt
claude --append-system-prompt "Always use TypeScript. Never use any."

# Load system prompt from file
claude --append-system-prompt-file ./coding-rules.txt

CLAUDE.md is the single most important file for customizing Claude Code behavior on a per-project basis. It loads automatically at the start of every session.

# My Project

## Build and Test
- Run tests: `npm test`
- Build: `npm run build`
- Lint: `npm run lint`

## Code Style
- Use TypeScript strict mode
- Prefer functional components in React
- All API responses must include error handling
- Never commit .env files

## Architecture
- Backend: Express.js + PostgreSQL
- Frontend: React + TailwindCSS
- Auth: JWT tokens stored in httpOnly cookies

See @README.md for project overview.
See @package.json for available scripts.

The @filename syntax imports content from other files. Claude reads them automatically.

Rules that only apply to certain files. Create .claude/rules/api.md:

---
paths:
  - "src/api/**/*.ts"
---

# API Rules
- All endpoints must validate input with Zod
- Return proper HTTP status codes
- Include rate limiting on public endpoints

Generate a CLAUDE.md automatically for any project with /init.

Claude Code asks permission before running commands or editing files. Toggle between modes with Shift+Tab:

Via the CLI:

# Allow git commands and file reads without prompting
claude --allowedTools "Read,Bash(git *)"

# Block dangerous tools explicitly
claude --disallowedTools "Bash(rm:*),Bash(sudo:*),Bash(chmod:*)"

# Combine both: allow some, block others
claude --allowedTools "Bash(git:*),Read,Edit" --disallowedTools "Bash(rm -rf:*)"

Or in .claude/settings.json:

{
  "permissions": {
    "allow": [
      "Read",
      "Bash(git *)",
      "Bash(npm run *)",
      "Bash(docker compose *)"
    ],
    "deny": [
      "Bash(rm -rf *)"
    ]
  }
}

Switch models mid-session with /model opus or Option+P (Mac) / Alt+P (Linux/Windows).

Effort levels control how much reasoning Claude applies:

MCP (Model Context Protocol) lets Claude Code connect to external tools and data sources. Configure servers in .mcp.json at the project root or ~/.claude/.mcp.json for all projects.

Example configuration with GitHub and PostgreSQL servers:

{
  "mcpServers": {
    "github": {
      "type": "stdio",
      "command": "npx",
      "args": ["@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "$GITHUB_TOKEN"
      }
    },
    "postgres": {
      "type": "stdio",
      "command": "npx",
      "args": ["@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@localhost:5432/mydb"
      }
    }
  }
}

Manage MCP connections with /mcp in the interactive session or pass a config file on the CLI:

# Load MCP servers from an external config
claude --mcp-config ./team-mcp.json

# Load multiple configs
claude --mcp-config ./github-mcp.json ./db-mcp.json

# Ignore all other MCP sources, only use this config
claude --mcp-config ./ci-mcp.json --strict-mcp-config

The --mcp-config flag is useful in CI/CD where you need consistent MCP server configuration across runs. --strict-mcp-config ensures only the specified servers are loaded, ignoring any from .mcp.json or user settings.

Skills are reusable prompts that show up as slash commands. Create them at .claude/skills/ (project) or ~/.claude/skills/ (personal).

Example: create a deploy skill:

mkdir -p .claude/skills/deploy

Create .claude/skills/deploy/SKILL.md:

---
name: deploy
description: Deploy the application to production
argument-hint: "[environment]"
user-invocable: true
---

Deploy the application to the $0 environment (default: staging).

Steps:
1. Run the test suite
2. Build the production bundle
3. Deploy using the deploy script
4. Verify the deployment health check

Now use it: /deploy production

Subagents are specialized AI agents that Claude can delegate tasks to. Create them at .claude/agents/:

mkdir -p .claude/agents/code-reviewer

Create .claude/agents/code-reviewer/AGENT.md:

---
name: code-reviewer
description: Expert code reviewer. Use proactively after code changes.
tools: Read, Grep, Glob, Bash
model: sonnet
---

You are a senior code reviewer. When reviewing code:
- Check for security vulnerabilities (SQL injection, XSS, etc.)
- Verify error handling is complete
- Flag any hardcoded secrets or credentials
- Suggest performance improvements
- Check for proper input validation

Claude automatically delegates code review tasks to this agent, or invoke it directly with @code-reviewer check my latest changes.

From the CLI, select an agent for the entire session:

# Use a named agent from .claude/agents/
claude --agent code-reviewer

# In print mode (CI/CD)
claude -p "review the latest commit" --agent code-reviewer

# Define agents inline (no files needed)
claude --agents '{"qa": {"description": "QA tester", "prompt": "You are a QA engineer. Write test cases for every change."}}'

Hooks run shell commands automatically in response to Claude Code events. Configure in .claude/settings.json:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write $(jq -r '.tool_input.file_path')"
          }
        ]
      }
    ],
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "osascript -e 'display notification \"Claude needs input\" with title \"Claude Code\"'"
          }
        ]
      }
    ]
  }
}

Common hook events: SessionStart, PreToolUse, PostToolUse, Stop, Notification, UserPromptSubmit.

Claude Code has a finite context window. Managing it well is the difference between a productive session and hitting walls.

• Use /clear between unrelated tasks. Do not carry old context into new work
• Run /compact proactively when you notice slowdowns
• Use subagents for verbose operations (test runs, log analysis). Their output stays in the subagent context
• Move detailed instructions to skills instead of typing them every time
• Keep CLAUDE.md under 200 lines. Move details to separate files and import with @filename

Work on multiple tasks simultaneously without branch switching conflicts:

# Start Claude in a new worktree
claude -w feature-auth

# Batch changes across many files in parallel
/batch migrate all components from class-based to functional

The -w flag creates an isolated git worktree. Changes happen in the worktree without affecting your main working directory. When the agent finishes, merge the worktree branch back.

Common settings:

{
  "model": "sonnet",
  "effortLevel": "medium",
  "defaultMode": "default",
  "autoMemoryEnabled": true,
  "permissions": {
    "allow": ["Read", "Bash(git *)"],
    "deny": ["Bash(rm -rf *)"]
  }
}

# User-level (personal, all projects)
~/.claude/
  settings.json          # Global settings
  keybindings.json       # Custom keyboard shortcuts
  CLAUDE.md              # Personal instructions
  rules/                 # Personal rules
  agents/                # Personal subagents
  skills/                # Personal skills
  .mcp.json              # Global MCP servers

# Project-level (shared with team)
.claude/
  settings.json          # Project settings (git tracked)
  settings.local.json    # Local overrides (gitignored)
  CLAUDE.md              # Project instructions
  rules/                 # Path-specific rules
  agents/                # Project subagents
  skills/                # Project skills
.mcp.json                # Project MCP servers
CLAUDE.md                # Project instructions (alternative location)

# In your project root
claude
/init

This scans your project and generates a CLAUDE.md with build commands, test instructions, and code conventions. Review and edit it. This file shapes every future interaction.

Press Shift+Tab to enter plan mode before asking Claude to make changes. In plan mode, Claude reads and analyzes but cannot edit anything. Once you approve the plan, switch back to default mode and say "implement the plan".

Press Esc + Esc to open the rewind menu. Choose "Restore code and conversation" to undo both the code changes and the conversation that led to them. Faster than git stash for quick experiments.

# Analyze logs
tail -500 /var/log/app.log | claude -p "find the root cause of errors"

# Review a PR
gh pr diff 42 | claude -p "security review this PR"

# Generate commit message
git diff --staged | claude -p "write a conventional commit message" --model haiku

# Translate
cat README.md | claude -p "translate to Japanese" > README.ja.md

# Docker container analysis
docker ps --format json | claude -p "which containers are using the most resources?"

# Kubernetes pod debugging
kubectl logs deployment/api --tail=200 | claude -p "why are requests failing?"

# Database structure review
pg_dump --schema-only mydb | claude -p "suggest index improvements"

# Summarize recent commits
git log --oneline -20 | claude -p "write release notes from these commits"

# Find config issues
cat /etc/nginx/nginx.conf | claude -p "check for misconfigurations"

Need to ask something without derailing the current task? Use /btw:

/btw what was the name of that config file we edited earlier?

The response is ephemeral (not saved to context), low-cost (uses cache), and does not use any tools.

• Use /cost to check spend at any time
• Use Sonnet for most work, Opus only for complex problems
• Use /effort low for simple tasks
• Run /compact to reduce context size (fewer tokens per request)
• Be specific in prompts. Vague requests cause more back-and-forth
• Use --max-budget-usd 5.00 in CI/CD to prevent runaway costs

The quality of Claude Code's output depends heavily on how you prompt it. These patterns consistently produce better results.

For complex tasks, switch to plan mode (Shift+Tab) and ask Claude to explore before coding:

# In plan mode:
"I need to add OAuth2 login with Google. Look at the existing auth flow
in src/auth/ and propose where to add the Google provider without
breaking the current email/password login."

Review the plan, then switch back to default mode and say "implement the plan".

Tell Claude how to verify its own work:

"Add rate limiting to the /api/auth endpoints. After implementing,
run npm test to make sure nothing breaks, and verify the rate limiter
works by checking the middleware is registered in the Express app."

Point Claude at specific files instead of making it search:

"look at @src/db/schema.ts and @src/api/users.ts - the User model
has a new 'role' field in the schema but the API doesn't expose it.
Add the role field to the GET /users/:id response."

If you see Claude going in the wrong direction, press Ctrl+C to stop and redirect. Do not wait for it to finish a large wrong change. If it already made bad changes, press Esc + Esc to rewind.

Instead of "build a user management system", split it:

1. "Create the User database schema with id, email, name, role, created_at"
2. "Add CRUD API endpoints for users with input validation"
3. "Write tests for the user endpoints"
4. "Add role-based access control middleware"

Each step gets verified before moving to the next. This avoids wasting tokens on a bad foundation.

Every message sent to Claude includes the full conversation context. Larger context means higher cost and slower responses.

• Keep the main CLAUDE.md under 200 lines. It loads on every message
• Move detailed instructions into skills. They only load when invoked
• Use @file imports for large reference docs instead of pasting content
• Put path-specific rules in .claude/rules/. They only load when Claude touches matching files

• Disable unused MCP servers with /mcp. Each server adds tool definitions to context
• Use CLI tools (gh, aws, gcloud) instead of MCP when a single command works
• Set ENABLE_TOOL_SEARCH=auto:5 to auto-defer tool definitions when they exceed 5% of context

# Hard spending limit
claude -p "fix failing tests" --max-budget-usd 2.00

# Limit agentic turns
claude -p "review this file" --max-turns 3

# Use cheapest model for simple CI tasks
claude -p "check for linting errors" --model haiku

When you need to see exactly what Claude Code is doing (API calls, tool invocations, timing):

# Full debug output to stderr
claude --debug

# Filter to specific categories
claude --debug "api,hooks"

# Write debug logs to a file (keeps terminal clean)
claude --debug-file /tmp/claude-debug.log

Useful when MCP servers are not connecting, hooks are not firing, or API calls are failing silently.

Run /doctor when something is not working right. It checks:

• Claude Code version and auto-updater status
• Authentication state and token validity
• API connectivity
• Settings file syntax and conflicts
• MCP server health
• Permission configuration

Run /insights after a long session to get an analysis report covering:

• Token usage breakdown by category
• Most expensive operations in the session
• Patterns in how you use Claude Code
• Suggestions for improving efficiency
• Time spent waiting vs. actively working

Use this to identify habits that waste tokens and adjust your workflow.

Claude Code integrates with VS Code and JetBrains IDEs for inline diffs, context sharing, and side-by-side conversations.

• Install the "Claude Code" extension from the VS Code marketplace
• Open Command Palette (Cmd+Shift+P on Mac / Ctrl+Shift+P on Linux/Windows) and search "Claude Code"
• Works with Cursor editor too

• Install "Claude Code" from the JetBrains Marketplace
• Works across all JetBrains IDEs
• Supports interactive diffs and context sharing

Start Claude with IDE auto-detection:

claude --ide

Auto mode uses an AI classifier to decide whether each tool call needs your approval. Instead of prompting on every command, it allows safe operations (reads, git status, test runs) and blocks risky ones (force push, rm -rf, production deploys) automatically. Enable it with --permission-mode auto or press Shift+Tab to cycle to it.

Inspect the classifier rules:

# View current auto-mode config
claude auto-mode config

# View default allow/deny rules
claude auto-mode defaults

# Get AI feedback on your custom rules
claude auto-mode critique

Customize rules in .claude/settings.json or ~/.claude/settings.json under the autoMode key with allow, soft_deny, and environment arrays.

Chain multiple claude -p calls in a bash script for repeatable workflows:

#!/bin/bash
# Automated PR review pipeline
git diff HEAD~1 > /tmp/diff.txt
cat /tmp/diff.txt | claude -p "review for security issues" --model sonnet > security_review.md
cat /tmp/diff.txt | claude -p "check for performance regressions" --model sonnet > perf_review.md
cat /tmp/diff.txt | claude -p "write a one-paragraph summary" --model haiku > summary.md

Batch process multiple files:

#!/bin/bash
# Generate docstrings for all Python files missing them
for f in $(grep -rL '"""' src/*.py); do
  claude -p "add docstrings to functions missing them in $f" \
    --allowedTools "Read,Edit" --max-turns 3
done

Generate a changelog from git tags:

git log v1.0.0..v2.0.0 --oneline | \
  claude -p "create a changelog grouped by feature, fix, and chore" \
  --output-format text > CHANGELOG.md

The /loop slash command runs a prompt or another slash command on a repeating interval within your session:

# Check deploy status every 5 minutes
/loop 5m check if the deploy on staging is complete

# Run tests every 10 minutes (default interval)
/loop /test

# Custom interval with a slash command
/loop 2m /security-review

The loop runs in the background until you stop it or end the session. Each iteration gets its own context, so long-running loops do not bloat the conversation.

The 20 commands and shortcuts you will use every day:

• Official Claude Code Documentation
• Claude Code for DevOps Engineers
• Full cheat sheet with screenshots
• Anthropic API Documentation
• MCP Documentation

Found a missing command or outdated flag? Open an issue or submit a PR. All contributions are welcome.

This project is licensed under the MIT License. See LICENSE for details.