Claude Code Cheat Sheet 2026

Complete reference for slash commands, bundled skills, CLI flags, keyboard shortcuts, environment variables, hooks, config files, and scheduling. Updated through v2.1.81.

Major Features

New capabilities shipped in the past 30 days (v2.1.63 through v2.1.81):

• Auto Mode (research preview) — AI classifier reviews every tool call before execution; replaces manual permission approvals; toggle with --enable-auto-mode or Shift+Tab
• Agent Teams — multiple Claude Code instances working in parallel, each with own context window and git worktree; requires v2.1.32+
• Code Review (multi-agent) — dispatches parallel review agents on PR open; each agent reviews a different dimension
• AutoMemory — automatically writes memory rules from session habits; stored in .claude/skills/; persists per project
• Voice Mode (/voice) — push-to-talk via spacebar; 20 languages supported; keybinding configurable via keybindings.json
• 1M Token Context Window (GA) — Opus 4.6 on Max, Team, and Enterprise plans; no beta header required
• Opus 4.6 as default model — replaces Sonnet 4.5; 64k default output, 128k upper bound; Sonnet 4.6 also at 128k upper
• Remote Control — control a live session from browser or phone via claude.ai/code
• Desktop Scheduled Tasks — persistent cron-style tasks that survive restarts; local file/MCP access
• Cloud Scheduled Tasks (/schedule) — tasks run on Anthropic infrastructure; survive closed laptops
• MCP Elicitation — MCP servers can request structured input mid-task via interactive form or browser URL
• Fast Mode — speed-optimized API settings for Opus 4.6; ~2.5x speed, ~2x cost; best for live iteration
• /simplify and /batch — two new bundled skills (shipped v2.1.63, Feb 28 2026)
• /loop — in-session cron scheduler (shipped March 2026; up to 7 days)
• /btw — side-channel mid-task annotation without interrupting Claude
• MCP tool search (lazy loading) — reduces context usage ~95% by loading tools on demand

Bundled Skills

Built-in skills shipped with Claude Code. Zero setup. Available in every session.

Slash Commands

Session Management

Context and Files

Model and Effort

Permissions and Config

Scheduling

Agentic / Multi-Agent

Voice and Remote

Info and Diagnostics

Plugin Management

MCP

Init and Setup

Color and UX

Input Prefix Shortcuts

CLI Flags

Session Startup

Model and Effort

Automation and Scripting

Context and Directories

Multi-Agent

MCP

Maintenance

Keyboard Shortcuts

macOS: Alt = Option. Configure Option as Meta in iTerm2: Settings > Profiles > Keys > Left Option = Esc+

Navigation and Control

Input Editing (Multi-line)

Clipboard and Files

Custom Keybindings

Rebind any action in ~/.claude/keybindings.json:

{
  "bindings": [
    {
      "context": "Chat",
      "bindings": {
        "ctrl+k ctrl+s": "chat:stash",
        "ctrl+shift+p": "chat:modelPicker",
        "ctrl+g": "chat:externalEditor"
      }
    },
    {
      "context": "Global",
      "bindings": {
        "ctrl+shift+t": "app:toggleTodos"
      }
    }
  ]
}
Click to copy

Available actions include: chat:submit, chat:externalEditor, chat:stash, chat:modelPicker, app:toggleTodos, task:background, chat:killAgents

Thinking / Effort Keywords

Type these keywords anywhere in your prompt to control reasoning depth for that turn:

Note: ultrathink overrides the session effort level for that turn only. Best paired with Opus 4.6 + Plan Mode for multi-file features.

Environment Variables

Model and API

Behavior Control

Security and Subprocesses

Plugins and Seeds

Hooks and Sessions

Scheduling

Hooks

Hooks fire at specific lifecycle events and can run shell commands, POST to URLs, or intercept/block actions.

Hook Events

Hook Types

Hook Fields (New in 2026)

• agent_id and agent_type — available in all hook events for subagent tracking and logging
• Hook source display in permission prompts — shows whether hook came from settings, plugin, or skill

Example: Block rm -rf in PreToolUse

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/validate-bash.sh"
          }
        ]
      }
    ]
  }
}
Click to copy

Scheduling

Three scheduling options depending on persistence needs:

/loop — In-Session (CLI)

/loop [interval] <prompt>
/loop 5m check if the deployment finished
/loop 1h run test suite and report failures
/loop babysit all PRs and auto-fix build issues
Click to copy

• Units: s (seconds, rounds up to 1m), m, h, d
• Max duration: 7 days (then auto-expires)
• Max tasks per session: 50
• Session-scoped: all tasks die when you exit
• Fires between turns, never mid-response
• One-shot: describe in natural language without an interval; Claude schedules a single-fire task that deletes itself

Manage tasks:

show running cron jobs      # CronList
cancel loop c21d95a0        # CronDelete by ID
Click to copy

Disable entirely:

CLAUDE_CODE_DISABLE_CRON=1 claude
Click to copy

Desktop Scheduled Tasks — Persistent Local

• Configured in the Desktop sidebar: Scheduler > + New Task
• Survives restarts; runs as long as Desktop app is open
• Full access to local files, MCP servers, skills, plugins
• Supports model selection, permission mode, working folder, worktree isolation

/schedule — Cloud Tasks

/schedule run security audit every Monday at 9am
/schedule resolve CI failures on every failed build
Click to copy

• Runs on Anthropic infrastructure
• Survives closed laptops
• Used for continuous automation (CI fixes, doc updates, nightly builds)

Agent Teams

Run multiple Claude Code instances in parallel, each in its own context and worktree.

Requires: v2.1.32+

Best use cases:

• Parallel code review (security, performance, architecture simultaneously)
• New modules where agents can own separate pieces
• Debugging with competing hypotheses
• Cross-layer changes (frontend + backend + tests)

Key behaviors:

• Lead agent orchestrates; teammate agents work independently
• Each teammate gets its own git worktree; no merge conflicts
• Killing a background agent preserves its partial results in conversation context
• SendMessage({to: agentId}) to continue a stopped agent
• agent_id and agent_type fields in all hook events for tracking

Agent frontmatter:

---
effort: high
maxTurns: 20
disallowedTools: [Bash]
initialPrompt: "Review the auth module for security issues"
---
Click to copy

Permissions System

Permission Modes (Shift+Tab cycles through these)

Permission Rules in settings.json

{
  "permissions": {
    "allow": [
      "Read",
      "Bash(git *)",
      "Bash(npm run *)",
      "Bash(docker compose *)",
      "WebSearch",
      "WebFetch(domain:github.com)"
    ],
    "ask": [
      "Write(*.ts)",
      "Bash(git push*)"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Read(.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Write(package-lock.json)"
    ]
  }
}
Click to copy

Rule evaluation order: deny checked first, then ask, then allow. First match wins.

Auto Mode (Research Preview)

• Enable: claude --enable-auto-mode or Shift+Tab to cycle to it
• Classifier blocks: scope escalation, untrusted infrastructure, mass file deletion, prompt injection attempts
• Recommended: run in isolated environments (containers, VMs, sandboxes)
• Available: Team plan (rolling out to Enterprise and API)

Config File Structure

~/.claude/                          # Global / personal (never committed)
  settings.json                     # Global permissions and defaults
  CLAUDE.md                         # Global instructions (all projects)
  keybindings.json                  # Custom keyboard shortcuts
  commands/                         # Personal slash commands
  skills/                           # Personal skills
  agents/                           # Personal subagent personas
  projects/<project>/memory/        # AutoMemory files (MEMORY.md + topic files)

your-project/
  CLAUDE.md                         # Team instructions (committed)
  CLAUDE.local.md                   # Personal overrides (gitignored)
  .mcp.json                         # MCP server configs
  .claude/
    settings.json                   # Project permissions (committed)
    settings.local.json             # Personal permission overrides (gitignored)
    rules/                          # Modular instruction files by condition
    commands/                       # Custom slash commands
    skills/                         # Auto-invoked workflows
    agents/                         # Specialized subagent personas
    hooks/                          # Event-driven automation scripts
Click to copy

Settings Precedence (highest to lowest)

Managed (org policy) > CLI args > Local settings > Project settings > User settings
Click to copy

settings.json Key Fields

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "model": "opus",
  "effortLevel": "medium",
  "defaultMode": "default",
  "autoMemoryEnabled": true,
  "autoMemoryDirectory": "~/.claude/memory/",
  "permissions": {
    "allow": [],
    "ask": [],
    "deny": []
  },
  "env": {
    "CLAUDE_CODE_EFFORT_LEVEL": "medium",
    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "80"
  },
  "attribution": {
    "commit": "Co-Authored-By: Claude",
    "pr": "Generated with Claude Code"
  },
  "sandbox": {
    "enabled": true,
    "filesystem": {
      "allowWrite": [],
      "denyRead": [],
      "allowRead": []
    }
  },
  "feedbackSurveyRate": 0,
  "companyAnnouncements": []
}
Click to copy

CLAUDE.md Quick Reference

Location hierarchy:

1. ~/.claude/CLAUDE.md — global, all projects
2. <project>/CLAUDE.md — project-level (committed, team-shared)
3. <project>/CLAUDE.local.md — personal overrides (gitignored)

Best practices:

• Keep under 200-300 lines; shorter is better
• Put build/test/lint commands at the top
• Reference detailed docs by path instead of inlining (See docs/ARCHITECTURE.md)
• Use .claude/rules/ for modular, condition-specific instructions
• Press # during any session to open the memory prompt and update CLAUDE.md on the fly

Minimal starter:

# Project: my-app

# Commands
- Build: `npm run build`
- Test: `npm test`
- Lint: `npm run lint -- --fix`

# Conventions
- TypeScript strict mode
- No default exports
- Commits: feat/fix/chore(scope): description

# Key References
- Architecture: docs/ARCHITECTURE.md
- DB schema: docs/SCHEMA.md
Click to copy

MCP Integration

# Add an MCP server
claude mcp add --transport http github https://mcp.github.com
claude mcp add --transport stdio postgres npx @modelcontextprotocol/server-postgres

# Expose Claude Code as an MCP server
claude mcp serve

# Debug MCP connection
claude --debug "mcp"
Click to copy

.mcp.json example:

{
  "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"
      }
    }
  }
}
Click to copy

MCP tool search (lazy loading):

• Enabled by default since early 2026
• Reduces context usage ~95%; tools loaded on demand
• Set ENABLE_TOOL_SEARCH=true when using ANTHROPIC_BASE_URL

MCP Elicitation:

• MCP servers can display interactive forms or open browser URLs mid-task to collect structured input
• Intercept with Elicitation and ElicitationResult hooks

MCP channels (--channels):

• Research preview
• Allows MCP servers to push messages into your active session
• Channel servers with permission capability can forward tool approval prompts to your phone

Plugin Marketplace

Available on Team and Enterprise plans.

Install and manage:

/plugin                         # Open marketplace browser
/plugin install owner/repo      # Install from GitHub
/plugin validate                # Validate frontmatter + hooks
/plugin uninstall <name>        # Uninstall (prompts before deleting data)
Click to copy

Available plugin collections:

• Knowledge Work Plugins — 11 categories (productivity, research, writing, etc.)
• Financial Services Plugins — 41 skills with MCP data integrations

Inline plugin source (no marketplace entry needed):

{
  "plugins": [
    {
      "source": "settings",
      "name": "my-plugin",
      "skills": [...]
    }
  ]
}
Click to copy

Plugin persistent state:

• ${CLAUDE_PLUGIN_DATA} — data directory that survives plugin updates
• Ref-tracked plugins re-clone on every load to pick up upstream changes

Skills System (Custom)

File Structure

.claude/skills/<skill-name>/
  SKILL.md           # Required: frontmatter + instructions
  support-file.md    # Optional: templates, examples, reference docs
  script.sh          # Optional: supporting scripts
Click to copy

SKILL.md Frontmatter Reference

---
name: skill-name                        # becomes /skill-name
description: When to use this skill     # Claude reads this to auto-invoke
argument-hint: "[arg1] [arg2]"          # Shown in /help
allowed-tools: [Read, Bash(git *)]      # Restrict tool access
model: sonnet                           # Override model for this skill
effort: low                             # Override effort level (low/medium/high)
disable-model-invocation: false         # true = never auto-invoke
user-invocable: true                    # Show in /help listing
context: fork                           # Run in a subagent (keeps main context clean)
agent: Explore                          # Use a specific built-in agent type
initialPrompt: "Start by reading..."   # Auto-submits first turn in agent
maxTurns: 20                            # Limit agent turns
disallowedTools: [Bash]                 # Block specific tools in this skill
---
Click to copy

Variables in Skills

Scopes

Commands vs Skills (Unified since v2.1.3)

• .claude/commands/*.md — legacy format; still works; single-file; manual invocation only
• .claude/skills/*/SKILL.md — recommended format; supports auto-invocation, supporting files, full frontmatter
• Both invoke with /name; skills support richer features

Quick Reference: Effort Levels

max effort level removed in March 2026. Use ultrathink keyword for single-turn max depth.

Quick Reference: Scheduling Decision Tree

Need to schedule a task?
├── In current terminal session only?
│   └── /loop [interval] <prompt>
│
├── Needs to survive session close but run locally?
│   └── Desktop Scheduled Tasks (Desktop sidebar)
│
├── Needs to run without your machine / laptop closed?
│   └── /schedule (cloud tasks on Anthropic infra)
│
└── Needs to run on every git event / CI trigger?
    └── GitHub Actions with Claude Code SDK
Click to copy

Common Workflow Patterns

Start a new project

/init           # interview-based CLAUDE.md generation
/plan           # review approach before touching files
Click to copy

Long session hygiene

/context        # check window usage
/compact        # compress when > 80% full; add focus instructions
/clear          # hard reset when switching tasks
Click to copy

Safe large-scale changes

/batch migrate all API calls to use the new fetch wrapper
# Review plan > approve > agents run in isolated worktrees > PRs created
Click to copy

Code cleanup before PR

/simplify                       # full 3-agent review
/simplify focus on memory leaks # targeted review
Click to copy

Monitor a deployment

/loop 2m check deploy status and notify me if it fails
Click to copy

Ask a side question without derailing Claude

/btw what was the config file path we used earlier?
Click to copy

Recover from a mistake

Esc + Esc       # open rewind menu
# choose: Rewind code only  (keep conversation)
# or: Rewind code and conversation
Click to copy

Multi-model cost optimization

/model sonnet   # default; handles 80% of tasks
/model opus     # switch for complex architecture or hard bugs
ultrathink      # force max reasoning for one turn without switching models
/model sonnet   # switch back after the hard part
Click to copy

Last updated: March 2026 | Covers Claude Code v2.1.63 through v2.1.81 Run claude --version to check your current version Run /release-notes inside a session for the latest changes