Supports Claude Code, Cursor, Mcp

If you're in a hurry, here's the fastest way to add:

# Add file system access (most commonly used)
claude mcp add filesystem -s user -- npx -y @modelcontextprotocol/server-filesystem ~/Documents ~/Desktop

# Verify if successful
claude mcp list

Responce if it worked like it should:

Start and resume

claude # Start interactive REPL claude "explain this project" # Start REPL seeded with a prompt claude -p "summarize README.md" # Non-interactive print mode (SDK-backed) cat logs.txt | claude -p "explain" # Pipe input to Claude and exit claude -c # Continue most recent conversation claude -r "" "finish this" # Resume by ID or name claude --model sonnet # Pick the Sonnet alias for this run claude --model opus # Pick the Opus alias for harder tasks

Install, update, and auth

claude update # Manually update Claude Code claude doctor # Diagnose install/version & setup claude install # Start the native binary installer claude migrate-installer # Switch from global npm to the native installer claude auth login # Log in to your Anthropic account claude auth status # Check authentication status claude auth logout # Log out

Background and remote sessions

claude agents # Open the live session dashboard: running, blocked, completed claude agents --json # Scriptable JSON list of live/background sessions claude --bg "run the integration suite and summarize failures" # Start a background session claude --bg --exec "npm test" # Run a shell command as an attachable background session claude remote-control # Start remote-control mode for external tooling claude --remote "Fix the bug" # Create web session on claude.ai claude --teleport # Resume web session locally

Config essentials

claude config # Interactive config wizard claude config set model "sonnet" # Override default model for this project claude config set attribution false # Disable "co-authored-by Claude" byline in git/PRs claude config set enableAllProjectMcpServers true # Auto-approve all MCP servers from .mcp.json claude config set defaultMode "acceptEdits" # Set default permission mode claude config set worktree.baseRef "head" # Use local HEAD instead of origin/default for new worktrees claude config set -g autoUpdates false # Turn off automatic updates globally claude config set -g theme dark # Theme: dark | light | light-daltonized | dark-daltonized

MCP essentials

claude mcp # Launch MCP wizard / configure MCP servers claude mcp list # List configured MCP servers claude mcp get # Show details for a server claude mcp add [args...] # Add local stdio server claude mcp add --transport http # Add remote HTTP server claude mcp reset-project-choices # Reset approvals for project .mcp.json servers claude mcp serve # Run Claude Code itself as an MCP stdio server

High-value flags

claude --add-dir ../apps ../lib # Add additional working directories claude --allowedTools "Bash(git log:*)" "Read" # Allow listed tools without permission prompts claude --disallowedTools "Edit" # Disallow listed tools without permission prompts claude -p "query" --output-format json --input-format stream-json # Control IO formats for scripting claude --verbose # Verbose logging (turn-by-turn) claude --dangerously-skip-permissions # Skip permission prompts (use with caution) claude --permission-mode plan # Start in plan mode (read-only analysis) claude --max-turns 3 -p "query" # Limit agentic turns (print mode only) claude --json-schema '{"type":"object"}' -p "query" # Get validated JSON output claude --chrome # Enable Chrome browser integration claude --agent code-reviewer # Run this session with a named agent claude ultrareview 123 --json # Non-interactive comprehensive review for PR/target 123

Slash shortcuts

claude --fork-session -r abc123 # Fork instead of reusing original claude -w "implement feature" # Start in an isolated git worktree /rename auth-refactor # Name current session /resume # Open session picker /export output.md # Export conversation to file /branch experiment-name # Branch the current conversation /goal "all tests pass and README is updated" # Keep working until the completion condition is met /loop 30m "check deploy health and summarize anomalies" # Schedule recurring work /workflows # View dynamic workflows and background orchestration

Notes: project scope is default for 'claude config'; use -g/--global for user-global settings.

Settings precedence: Enterprise > CLI args > local project > shared project > user (~/.claude).

---

<h1 id="interface--input">Interface & Input</h1>

<h2 id="keyboard-shortcuts">Keyboard Shortcuts</h2>

| Shortcut                     | Description                        | Context                                  |
| :--------------------------- | :--------------------------------- | :--------------------------------------- |
| `Ctrl+C`                     | Cancel current input or generation | Standard interrupt                       |
| `Ctrl+D`                     | Exit Claude Code session           | EOF signal                               |
| `Ctrl+G`                     | Open in default text editor        | Edit your prompt or custom response      |
| `Ctrl+L`                     | Clear terminal screen              | Keeps conversation history               |
| `Ctrl+O`                     | Toggle verbose output              | Shows detailed tool usage and execution  |
| `Ctrl+R`                     | Reverse search command history     | Search through previous commands         |
| `Ctrl+V` or `Cmd+V` (iTerm2) | Paste image from clipboard         | Pastes an image or path to an image file |
| `Ctrl+B`                     | Background running tasks           | Backgrounds bash commands and agents     |
| `Ctrl+F` (press twice)       | Kill all background agents         | Two-press confirmation to stop agents    |
| `Up/Down arrows`             | Navigate command history           | Recall previous inputs                   |
| `Left/Right arrows`          | Cycle through dialog tabs          | Navigate between tabs in dialogs         |
| `Esc` + `Esc`                | Rewind the code/conversation       | Restore to a previous point              |
| `Shift+Tab` or `Alt+M`       | Toggle permission modes            | Switch between Auto-Accept, Plan, Normal |
| `Option+P` (macOS) / `Alt+P` | Switch model                       | Switch models without clearing prompt    |
| `Option+T` (macOS) / `Alt+T` | Toggle extended thinking           | Enable/disable extended thinking mode    |

<h3 id="text-editing">Text Editing</h3>

| Shortcut               | Description                  | Context                               |
| :--------------------- | :--------------------------- | :------------------------------------ |
| `Ctrl+K`               | Delete to end of line        | Stores deleted text for pasting       |
| `Ctrl+U`               | Delete entire line           | Stores deleted text for pasting       |
| `Ctrl+Y`               | Paste deleted text           | Paste text deleted with Ctrl+K/U      |
| `Alt+Y` (after Ctrl+Y) | Cycle paste history          | Cycle through previously deleted text |
| `Alt+B`                | Move cursor back one word    | Requires Option as Meta on macOS      |
| `Alt+F`                | Move cursor forward one word | Requires Option as Meta on macOS      |

<h3 id="multiline-input">Multiline Input</h3>

| Method           | Shortcut       | Context                           |
| :--------------- | :------------- | :-------------------------------- |
| Quick escape     | `\` + `Enter`  | Works in all terminals            |
| macOS default    | `Option+Enter` | Default on macOS                  |
| Terminal setup   | `Shift+Enter`  | After `/terminal-setup`           |
| Control sequence | `Ctrl+J`       | Line feed character for multiline |
| Paste mode       | Paste directly | For code blocks, logs             |

<h3 id="quick-commands">Quick Commands</h3>

| Shortcut     | Description       | Notes                                 |
| :----------- | :---------------- | :------------------------------------ |
| `/` at start | Command or skill  | See built-in commands and skills      |
| `!` at start | Bash mode         | Run commands directly, add to context |
| `@`          | File path mention | Trigger file path autocomplete        |

> [!Tip]
> **PDF Page Ranges:** Use the `pages` parameter with the Read tool for PDFs (e.g., `pages: "1-5"`). Large PDFs (>10 pages) return a lightweight reference when @-mentioned instead of being inlined.

<h2 id="vim-mode">Vim Mode</h2>

> [!Note]
> Enable vim-style editing from `/config` -> Editor mode.

<h3 id="vim-mode-switching">Vim Mode Switching</h3>

| Command | Action                      | From mode |
| :------ | :-------------------------- | :-------- |
| `Esc`   | Enter NORMAL mode           | INSERT    |
| `i`     | Insert before cursor        | NORMAL    |
| `I`     | Insert at beginning of line | NORMAL    |
| `a`     | Insert after cursor         | NORMAL    |
| `A`     | Insert at end of line       | NORMAL    |
| `o`     | Open line below             | NORMAL    |
| `O`     | Open line above             | NORMAL    |

<h3 id="vim-navigation">Vim Navigation</h3>

| Command         | Action                    |
| :-------------- | :------------------------ |
| `h`/`j`/`k`/`l` | Move left/down/up/right   |
| `w`             | Next word                 |
| `e`             | End of word               |
| `b`             | Previous word             |
| `0`             | Beginning of line         |
| `$`             | End of line               |
| `^`             | First non-blank character |
| `gg`            | Beginning of input        |
| `G`             | End of input              |

<h3 id="vim-editing">Vim Editing</h3>

| Command        | Action                  |
| :------------- | :---------------------- |
| `x`            | Delete character        |
| `dd`           | Delete line             |
| `D`            | Delete to end of line   |
| `dw`/`de`/`db` | Delete word/to end/back |
| `cc`           | Change line             |
| `C`            | Change to end of line   |
| `cw`/`ce`/`cb` | Change word/to end/back |
| `.`            | Repeat last change      |

> [!Tip]
> Configure your preferred line break behavior in terminal settings. Run `/terminal-setup` to install Shift+Enter binding for iTerm2, VS Code, Kitty, Alacritty, Zed, Warp, and WezTerm.

<h2 id="command-history">Command History</h2>

> Claude Code maintains command history for the current session:

• History is stored per working directory
• Cleared with /clear command
• Use Up/Down arrows to navigate (see keyboard shortcuts above)
• Ctrl+R: Reverse search through history (if supported by terminal)
• Note: History expansion (!) is disabled by default

---

<h1 id="advanced-features">Advanced Features</h1>

<h2 id="thinking-keywords">Thinking Keywords</h2>

> [!Note]
> **Gives Claude extra pre-answer planning time by adding ONE of these keywords to your prompt.**
> **Order (lowest → highest) token consumption**
>
> <table><tr><td>
>
> > **<kbd>think</kbd> -------------> Lowest**
>
> > **<kbd>think hard</kbd>**
>
> > **<kbd>think harder</kbd>**
>
> > **<kbd>ultrathink</kbd> --------> Highest**
>
> </td></tr></table>

<h3 id="this-makes-claude-spend-more-time">This makes Claude spend more time:</h3>

1. **Planning the solution**
2. #### breaking down steps
3. #### weighing alternatives/trade-offs
4. #### checking constraints & edge cases
   > > #### Higher levels usually increase **latency** and **token usage** pick the smallest that works.

<h5 id="thinking-examples">Examples</h5>

```md
# Small boost

claude -p "Think. Outline a plan to refactor the auth module."

# Medium boost

claude -p "Think harder. Draft a migration plan from REST to gRPC."

# Max boost

claude -p "Ultrathink. Propose a step-by-step strategy to fix flaky payment tests and add guardrails."

Use /effort to tune how much reasoning the selected model applies before answering. Higher effort levels are best for planning-heavy work, deep reviews, and long-context tasks.

/effort            # Open the effort picker
/effort low        # Faster, lighter reasoning
/effort medium     # Balanced default for many tasks
/effort high       # Deeper planning and review
/effort xhigh      # Highest effort for Opus 4.8-scale hard tasks

Prefer the lowest effort that still solves the task: higher effort can improve planning, code review, and long-context reasoning, but it usually increases latency and token usage.

[!Note] Fast Mode provides accelerated Opus responses for rapid iteration when speed matters more than maximum depth.

How to enable Fast Mode:

# Enable usage credits if your plan requires it, then toggle fast mode
/usage-credits
/fast

# Or toggle during conversation
# The status bar will show when Fast Mode is active

Key features:

• Faster responses - Reduced latency for quick tasks
• Opus support - Use with Opus models where fast mode is available
• Usage credits - Some plans require /usage-credits before /fast
• Visible state - The status bar and IDE indicators show when Fast Mode is active

When to use Fast Mode:

• Quick code reviews and edits
• Rapid prototyping
• Simple questions and commands
• Iterative debugging

Fast Mode trades some depth for speed. Use normal mode for complex analysis and planning tasks.

Auto mode lets Claude evaluate and approve lower-risk actions automatically while still blocking or asking on higher-risk operations. It is useful for trusted development loops where repeated permission prompts slow down work.

# Enable auto mode for Bedrock, Vertex, and Foundry Opus 4.7/4.8 sessions
export CLAUDE_CODE_ENABLE_AUTO_MODE=1

{
  "autoMode": {
    "allow": ["$defaults"],
    "soft_deny": ["$defaults"],
    "hard_deny": []
  }
}

Key points:

• Enable auto mode through environment and settings so the policy is visible and repeatable.
• Use "$defaults" in autoMode.allow, autoMode.soft_deny, or autoMode.environment to add rules without replacing built-ins.
• settings.autoMode.hard_deny blocks actions unconditionally regardless of user intent.
• Denied actions can appear in /permissions recent activity, where supported, so you can retry or adjust policy.

[!Note] Plan Mode instructs Claude to analyze the codebase with read-only operations, perfect for exploring codebases, planning complex changes, or reviewing code safely.

When to use Plan Mode:

• Multi-step implementation: When your feature requires making edits to many files
• Code exploration: When you want to research the codebase thoroughly before changing anything
• Interactive development: When you want to iterate on the direction with Claude

How to enable Plan Mode:

# Start a new session in Plan Mode
claude --permission-mode plan

# Or toggle during session with Shift+Tab
# (cycles through: Normal → Auto-Accept → Plan Mode)

# Enter plan mode from the prompt
/plan

# Run headless queries in Plan Mode
claude --permission-mode plan -p "Analyze the authentication system and suggest improvements"

Configure Plan Mode as default:

// .claude/settings.json
{
  "permissions": {
    "defaultMode": "plan"
  }
}

[!Note] Claude Code supports background commands and full background sessions, allowing you to continue working while long-running processes or agents execute.

How to use background tasks:

Key features:

• Output is buffered and can be read from the persisted background output file path
• Background tasks have unique IDs for tracking and output retrieval
• Background sessions appear in /resume and the claude agents dashboard, marked with bg
• Use /tasks to list and manage background tasks
• Use claude agents --json for scripts, status bars, session pickers, and tmux integrations

Common backgrounded commands:

• Build tools (webpack, vite, make)
• Package managers (npm, yarn, pnpm)
• Test runners (jest, pytest)
• Development servers
• Long-running processes (docker, terraform)

Bash mode with ! prefix:

# Run bash commands directly without Claude interpretation
! npm test
! git status
! ls -la

# Run a command as an attachable background session
claude --bg --exec "npm test"

# Name a background session
claude --bg --name nightly-check "run the full verification suite"

Disable background tasks:

export CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1

Dynamic workflows coordinate many background agents for larger work than a single foreground turn can comfortably handle. Ask Claude to create a workflow, then use /workflows to inspect runs and status.

/workflows
/goal "the migration is implemented, tested, and documented"
/loop 15m "check the deployment dashboard and summarize any incidents"

Use workflows for broad, decomposable efforts. Use /goal for a single outcome that may require several turns. Use /loop for monitoring and scheduled checks.

[!Note] For subscribers: Use --remote to start tasks on claude.ai and --teleport to resume them locally.

Start a remote session:

# Create a new web session on claude.ai with task description
claude --remote "Fix the login bug"

Resume a remote session:

# Resume a web session in your local terminal
claude --teleport

# Or use the slash command
/teleport

Claude Code can control Google Chrome for browser-based tasks like testing, web scraping, and UI verification.

Setup:

claude --chrome                    # Launch with Chrome integration

Capabilities:

• Navigate to URLs, click elements, fill forms
• Take screenshots and analyze page content
• Execute JavaScript in the browser context
• Interact with web applications for testing

[!NOTE] Requires Google Chrome installed. Claude uses the Chrome DevTools Protocol for browser control.

Sandbox mode restricts the BashTool to run commands in an isolated environment, preventing modifications to your actual filesystem.

/sandbox              # Toggle sandbox mode on/off

When sandboxed:

• File system writes are contained
• Network access may be restricted
• Useful for testing destructive commands safely

Available on Linux and macOS. Use claude --sandbox to start in sandbox mode.

Claude Code integrates with language servers to provide IDE-level code intelligence:

• Go to Definition — Jump to where a symbol is defined
• Find References — Find all usages of a symbol across the codebase
• Hover Information — Get type information and documentation

The LSP tool activates automatically when a compatible language server is available for the current project. This enables Claude to navigate codebases more precisely than text search alone.

Tool results exceeding 50,000 characters are automatically persisted to disk to manage context efficiently.

Sub‑Agents are purpose‑built helpers with their own prompts, tools, and isolated context windows. Treat this like a "mixture‑of‑experts" you compose per repo.

Claude Code includes built-in subagents that Claude automatically uses when appropriate:

Claude delegates to Explore when it needs to search or understand a codebase without making changes, keeping exploration results out of your main conversation context.

When to use subagents:

• You need high signal responses (plans, reviews, diffs) without side quests.
• You want version‑controlled prompts and tool policies alongside the codebase.
• You work in PR‑driven teams and want scoped edits by role.
• The task produces verbose output you don't need in your main context.

Design rules for your lineup

• Define one clear responsibility per agent.
• Keep the minimum tool set needed for that role.
• Prefer read‑only agents for analysis/review tasks.
• Give edit powers to as few agents as possible.

Caption: Agents selection UI in the terminal.

Keep agents in the project so they're versioned with the repo and evolve via PRs.

Update CLI and open the agents panel/dashboard

claude update
/agents
claude agents
claude agents --json

claude agents shows running, blocked, completed, and background sessions in one place. It can launch new sessions, attach to background work, and script session lists with --json.

Dispatched sessions honor the agent field in settings.json. Pass --agent <name> to override the configured default for a specific run.

# Define custom subagents dynamically via JSON
claude --agents '{
  "code-reviewer": {
    "description": "Expert code reviewer. Use proactively after code changes.",
    "prompt": "You are a senior code reviewer. Focus on code quality, security, and best practices.",
    "tools": ["Read", "Grep", "Glob", "Bash"],
    "model": "sonnet"
  },
  "debugger": {
    "description": "Debugging specialist for errors and test failures.",
    "prompt": "You are an expert debugger. Analyze errors, identify root causes, and provide fixes."
  },
  "background-impl": {
    "description": "Implements features in an isolated worktree in the background.",
    "prompt": "Implement the requested feature. Commit when done.",
    "isolation": "worktree",
    "background": true
  }
}'

• planner (read‑only): turns features/issues into small, testable tasks; outputs a task list or plan.md.
• codegen (edit‑capable): implements tasks; limited to src/ + tests/.
• tester (read‑only or patch‑only): writes one failing test or a minimal repro.
• reviewer (read‑only): leaves structured review comments; never edits.
• docs (edit‑capable): updates README.md/docs/ only.

*Policy tip: Prefer patch output for edit‑capable agents so changes land through your normal Git workflow.*

Caption: Choose only the tools an agent truly needs (e.g., advisory vs editing access).

Keep prompts short, testable, and repo‑specific. Check them into agents/:

Caption: Example prompt for a test‑coverage‑analyzer agent.

tester.prompt.md (sample)

Role: Write a single, focused failing test for the specific scenario I describe.
Scope: Only create/modify tests under tests/. Do not change src/.
Output: A brief rationale + a unified diff or patch.
If the scenario is unclear, ask exactly one clarifying question.

Your tester agent should produce a small diff or patch plus a short rationale:

Caption: Example response from the test‑coverage‑analyzer agent.

Subagent files use YAML frontmatter for configuration:

---
name: code-reviewer
description: Reviews code for quality and best practices
tools: Read, Glob, Grep
disallowedTools: Write, Edit
model: sonnet
permissionMode: default
skills:
  - api-conventions
---

You are a code reviewer. Analyze the code and provide feedback.

Background and isolated agents can switch between Claude-managed worktrees with EnterWorktree when the session needs to move between related isolated checkouts.

Operational benefits

• Less context switching: you stay in one mental mode; agents do the rest.
• Cleaner PRs: narrow prompts + limited tools → smaller, reviewable diffs.
• Fewer regressions: tester/reviewer agents catch gaps before merge.
• Repeatability: prompts + policies live in the repo and travel with branches.

Security & governance

• Limit write access by path (e.g., src/, tests/, docs/).
• Favor read‑only analysis for high‑risk areas.
• Log/commit assistant outputs as patches for auditability.

Do

• Treat agents as teammates with job descriptions.
• Start read‑only; grant write access last.
• Keep prompts in version control and iterate via PR.

Don't

• Ask one agent to plan, code, and test in a single turn.
• Give blanket write permissions.
• Accept multi‑file diffs when you asked for one test.

[!Note] Agent Teams is an experimental feature enabling multiple Claude instances to work in parallel on a shared codebase autonomously.

Enable Agent Teams:

export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

Key Concepts:

• Multiple Claude instances run in parallel on the same codebase
• Each agent can specialize in different tasks (debugging, documentation, testing, etc.)
• Agents communicate through git-based synchronization
• Enables autonomous, long-running development workflows

Case Study: C Compiler Built by Agent Teams

Anthropic's research team demonstrated agent teams by tasking 16 parallel Claude instances to build a C compiler from scratch. Key results:

Lessons for Agent Teams:

1. Write high-quality tests - The task verifier must be nearly perfect
2. Design for parallelism - Agents should be able to work independently without blocking each other
3. Specialize agents - Dedicate agents to specific roles (code quality, documentation, performance)
4. Maintain context files - Keep READMEs and progress files updated for agent orientation

Read the full case study: Building a C Compiler with Parallel Claudes

[!Note] Skills extend what Claude can do. Create a SKILL.md file with instructions, and Claude adds it to its toolkit. Claude uses skills when relevant, or you can invoke one directly with /skill-name.

Project skills override personal skills with the same name. Files in .claude/commands/ still work and support the same frontmatter. Plugins in .claude/skills directories are automatically loaded; use /reload-skills to re-scan skill directories without restarting the session.

# Create skill directory
mkdir -p ~/.claude/skills/explain-code

# Scaffold a plugin-backed skill in the current project
claude plugin init explain-code

Create ~/.claude/skills/explain-code/SKILL.md:

---
name: explain-code
description: Explains code with visual diagrams and analogies. Use when explaining how code works.
---

When explaining code, always include:

1. **Start with an analogy**: Compare the code to something from everyday life
2. **Draw a diagram**: Use ASCII art to show the flow, structure, or relationships
3. **Walk through the code**: Explain step-by-step what happens
4. **Highlight a gotcha**: What's a common mistake or misconception?

Use the skill:

# Let Claude invoke automatically
How does this code work?

# Or invoke directly
/explain-code src/auth/login.ts

Use $ARGUMENTS placeholder to receive arguments:

---
name: fix-issue
description: Fix a GitHub issue
disable-model-invocation: true
---

Fix GitHub issue $ARGUMENTS following our coding standards.

1. Read the issue description
2. Implement the fix
3. Write tests
4. Create a commit

Usage: /fix-issue 123

Use !`command` syntax to run shell commands before the skill content is sent to Claude:

---
name: pr-summary
description: Summarize changes in a pull request
context: fork
agent: Explore
---