CtrlK
See also: Claude* Claude Code is an AI-powered command-line tool for agentic coding developed by Anthropic. First released as a beta research preview alongside Claude 3.7 Sonnet on February 24, 2025, and made generally available on May 22, 2025, Claude Code enables developers to delegate coding tasks to Claude directly from their terminal.[1][2]
On September 29, 2025, Anthropic released Claude Code version 2.0 with significant enhancements including checkpoints for safe rollbacks, a native VS Code extension, terminal v2.0 UX improvements, and the renamed Claude Agent SDK (formerly Claude Code SDK).[3][4] Version 2.1.0 followed with infrastructure-level features including hooks for agents and skills, hot reload for skills, session teleportation, and language-specific output.[5] By early 2026, Claude Code had grown into Anthropic's fastest-growing product, reaching $2.5 billion in annualized revenue and earning a 46% "most loved" rating among developers in industry surveys.[6][7]
In March 2026, Anthropic launched several major additions: Code Review, a multi-agent pull request analysis system; Claude Code Security for vulnerability scanning; Claude Code Channels for Telegram and Discord integration; voice mode; the /loop recurring task command; computer use integration on macOS; and a comprehensive Enterprise Analytics API.[41][42][43][44]
Claude Code functions as an AI pair programmer that understands entire codebases and assists developers through natural language commands. The tool executes routine tasks, explains complex code, handles Git workflows, and performs multi-file edits without requiring additional servers, remote code indexing, or complex setup.[8] It operates on the Unix philosophy, making it composable and scriptable within existing developer workflows.[9]
Unlike traditional code completion tools that offer inline suggestions, Claude Code takes an agentic approach to software development. When given a task, it autonomously reads files, searches codebases, writes and edits code, runs commands, and iterates on its own output. Developers interact with it through a terminal-based REPL (Read-Eval-Print Loop) where they describe what they want in plain English, and Claude Code plans and executes the necessary steps. This design makes it particularly effective for complex tasks that span multiple files or require deep understanding of project architecture.
The tool utilizes Claude models, with Claude Opus 4.6 (model ID: claude-opus-4-6-20260210) as the default model as of March 2026, featuring a 1M-token context window and 128K output token support.[10] Users on Max subscriptions have access to Opus 4.6 for complex tasks, while Claude Sonnet 4.5 remains available as a faster alternative for lighter workloads.[4] Claude Code achieved state-of-the-art performance on the SWE-bench Verified benchmark with an 80.9% score for Claude Opus 4.6, surpassing previous models and competitors.[10][11]
As of February 2026, Claude Code generates annualized run-rate revenue of over $2.5 billion. More than 500 enterprises spend over $1 million annually on Anthropic products, and Claude Code accounts for more than half of all enterprise spending on the platform. Business subscriptions quadrupled in the six weeks following January 1, 2026.[6][12]
Claude Code operates entirely from the terminal. After installation via npm or native binary, developers start it by running the claude command inside a project directory. The tool then enters an interactive REPL session where the developer can type natural language instructions.
When a developer submits a prompt, Claude Code follows a multi-step process:
find, glob, grep, and ripgrep. It examines relevant files, configuration, and any CLAUDE.md files present in the project hierarchy.All file edits, command executions, and tool invocations are displayed in the terminal, giving the developer full visibility into what Claude Code is doing at every step.
Claude Code uses a set of built-in tools to interact with the development environment:
| Tool | Purpose | Description |
|---|---|---|
| Read | File reading | Reads file contents with line numbers, supports images and PDFs |
| Edit | File editing | Applies targeted edits to specific sections of a file |
| Write | File creation | Creates new files or performs complete rewrites |
| Bash | Command execution | Runs shell commands in the project environment |
| Glob | File search | Finds files matching pattern expressions |
| Grep | Content search | Searches file contents using regular expressions |
| WebSearch | Web search | Searches the web for current information |
| WebFetch | URL fetching | Retrieves and processes content from URLs |
| MCP tools | External integrations | Tools provided by connected MCP servers |
Each tool call is shown to the user with a permission prompt. Users can approve individual calls, allow specific tools for the session, or configure permissions in advance through settings files.
Claude --dangerously-skip-permissions - Run Claude Code without permission prompts (use with caution)
claude -p "query" - Execute a programmatic query and exit
claude update - Update to latest version
claude mcp - Configure Model Context Protocol servers
/rewind - Restore to previous checkpoint (v2.0+)
/voice - Activate voice mode for push-to-talk input (March 2026)
/loop - Run a prompt on a recurring interval (March 2026)
Claude Code provides comprehensive development assistance through several key features:
| Feature | Description | Example Tasks |
|---|---|---|
| Build Features from Descriptions | Describe desired functionality in plain English; Claude creates a plan, writes code, and verifies it works | Refactors, API migrations, new feature implementation |
| Debug and Fix Issues | Describe bugs or paste error messages; Claude analyzes the codebase, identifies problems, and implements fixes | "Why is auth failing on refresh?" |
| File Management | Edit files and fix bugs across entire codebases with automatic context awareness | Multi-file refactoring |
| Code Analysis | Answer questions about code architecture and logic using agentic search | "Map out the payment module" |
| Testing & Quality | Execute and fix tests, linting, and other quality checks | "Run tests and fix failures in CI" |
| Version Control | Search git history, resolve merge conflicts, create commits and pull requests | "Open a PR implementing ticket #124" |
| Codebase Understanding | Agentic search to understand project structure without manual context selection | Automatic project exploration |
| Multi-file Editing | Make coordinated changes across multiple files simultaneously | Large-scale refactoring |
| Command Execution | Run shell commands and command line tools | "Build and start the dev server" |
| Checkpoints | Automatically save code state before changes with instant rollback capability (v2.0+) | Safe experimentation |
| Web Search | Search the internet for documentation, APIs, and current information | "Look up the latest React 19 API" |
| Code Review | Multi-agent PR analysis that catches bugs, security issues, and regressions (March 2026) | Automated pull request review |
| Voice Mode | Push-to-talk voice input for hands-free coding interaction (March 2026) | Dictating instructions while reviewing code |
The tool includes several advanced capabilities that distinguish it from traditional coding assistants:
Deep Codebase Awareness: Automatically explores and understands project structure through agentic search using tools like grep, find, and glob commands[8]
MCP Integration: Functions as both MCP server and client for extended tool access, supporting integrations with enterprise systems like Jira, Google Drive, Figma, and Slack[8]
IDE Integration: Native extensions for VS Code (generally available as of September 29, 2025) and beta extensions for JetBrains IDEs with inline edit display and real-time changes[3][13]
GitHub Integration: Can read issues, write code, run tests, submit pull requests, and automate workflows via GitHub Actions[8][14]
Background Tasks: Supports GitHub Actions integration for automated workflows and ensures uninterrupted running of development servers[2]
Checkpoints and Rewind: Automatically saves code states before each change, allowing rewinds via /rewind or double-Esc; applies to Claude's edits (not user shell commands). Three restore modes are available: Chat only (rewind history, preserve code), Code only (revert files, preserve conversation), and Both (complete restoration).[3]
Terminal 2.0 UX: Enhanced interface with Ctrl+R for command history search, improved status displays, and more transparent development flows[3]
Sub Agents: Supports parallel development, such as simultaneous front-end and back-end work; delegate specialized tasks to parallel agents for complex workflows[15]
Hooks: Automatically trigger actions at specific points in development workflow, such as running tests after code changes or checks before submissions[15]
Autonomous Operation: Can maintain focus for 30+ hours on complex, multi-step tasks with Claude Sonnet 4.5, including building full production-grade applications with over 11,000 lines of code[4]
Context Management: Automatic context compaction and summarization to prevent context window exhaustion[16]
Agent Teams: Coordinate multiple Claude Code instances working in parallel on shared codebases, with one session acting as team lead while teammates work independently in isolated branches (research preview, v2.1.32+)[17]
Voice Mode: Push-to-talk voice input activated via the /voice command. Hold the spacebar (or a custom keybinding) to speak, release to send. Supports 20 languages as of March 2026, with 10 new languages added that month (Russian, Polish, Turkish, Dutch, Ukrainian, Greek, Czech, Danish, Swedish, Norwegian).[44]
Loop Mode: The /loop command transforms Claude Code into a recurring monitoring and task-execution system. Developers define an interval and a prompt (for example, /loop 5m check the deploy), and Claude executes it automatically on that schedule.[44]
Computer Use: Integration with Anthropic's computer use capability, allowing Claude Code to interact directly with the user's screen, open applications, navigate browsers, and run development tools. Available as a research preview on macOS for Pro and Max subscribers (March 2026).[45]
Code Review for Claude Code, launched on March 9, 2026, is a multi-agent automated pull request analysis system that dispatches parallel AI agents to examine every PR for bugs, security vulnerabilities, and regressions. The feature is available as a research preview for Team and Enterprise customers.[41][46]
When a pull request opens on GitHub, multiple specialized agents analyze the code changes in parallel. Each agent targets a different class of issue: logic errors, boundary conditions, API misuse, authentication flaws, and compliance with project-specific conventions. A verification step then attempts to disprove each candidate finding to filter out false positives. Surviving findings are deduplicated, ranked by severity, and posted as inline comments on the specific lines of code where issues were found. If no issues are detected, Claude posts a short confirmation comment.[41]
Reviews scale in cost with PR size and complexity, completing in approximately 20 minutes on average.[41]
| Marker | Severity | Meaning |
|---|---|---|
| Red circle | Normal | A bug that should be fixed before merging |
| Yellow circle | Nit | A minor issue, worth fixing but not blocking |
| Purple circle | Pre-existing | A bug in the codebase that was not introduced by this PR |
Each finding includes a collapsible extended reasoning section that explains why Claude flagged the issue and how it verified the problem.[41]
Admins can configure when reviews run for each repository:
| Trigger | Behavior |
|---|---|
| Once after PR creation | Review runs once when a PR is opened or marked ready for review |
| After every push | Review runs on every push to the PR branch, auto-resolving threads when flagged issues are fixed |
| Manual | Reviews start only when someone comments @claude review on a PR |
Commenting @claude review on any pull request starts a review and opts that PR into push-triggered reviews going forward, regardless of the repository's configured trigger mode.[41]
Code Review reads two files from the repository to guide its analysis:
In Anthropic's internal data, 54% of pull requests received substantive comments (up from 16% with older approaches), and engineers marked less than 1% of findings as incorrect. For large PRs with over 1,000 lines changed, 84% received findings with an average of 7.5 issues per PR. For small PRs under 50 lines, 31% received findings with an average of 0.5 issues per PR.[46]
Code Review is billed based on token usage, with each review averaging $15 to $25 in cost. The cost scales with PR size, codebase complexity, and the number of issues requiring verification. Code Review usage is billed separately through extra usage and does not count against the plan's included usage. Admins can set monthly spend caps per organization.[41]
Claude Code Security, launched on February 20, 2026, scans codebases for security vulnerabilities and suggests targeted patches for human review. Unlike traditional static analysis tools that rely on pattern matching against known vulnerability signatures, Claude Code Security reads and reasons about code semantically, understanding how components interact and tracing how data moves through applications.[47]
The system detects complex vulnerabilities that rule-based tools typically miss, including:
| Vulnerability Type | Description |
|---|---|
| Business logic flaws | Errors in application logic that can be exploited |
| Broken access control | Missing or incorrect authorization checks |
| SQL injection | Unsanitized inputs in database queries |
| Cross-site scripting (XSS) | Unescaped user input rendered in web pages |
| Authentication flaws | Weaknesses in login, session, or token management |
| Insecure data handling | Improper storage or transmission of sensitive data |
| Dependency vulnerabilities | Known issues in third-party libraries |
Every finding undergoes a multi-stage verification process. Claude re-examines results to filter false positives, assigns severity ratings, and provides confidence ratings for each finding. Human approval is required before any patches are applied.[47]
Claude Code Security is available in a limited research preview for Enterprise and Team customers. Open-source maintainers receive expedited, free access. The feature is built on Claude Opus 4.6 and integrated into Claude Code on the web.[47]
Using Claude Opus 4.6, Anthropic's team found over 500 vulnerabilities in production open-source codebases that had gone undetected for decades, despite years of expert review.[47]
Claude Code Channels, announced on March 20, 2026 as a research preview, allow external messaging platforms to push events into a running Claude Code session. The feature shipped with Telegram and Discord support, with a plugin architecture designed for future expansion to additional platforms.[42][48]
A channel is an MCP server that runs on the same machine as Claude Code. Claude Code spawns it as a subprocess and communicates over stdio. When a message arrives from an external platform (for example, a Telegram DM or a Discord message), the channel plugin receives the message and forwards it to Claude as a channel event. Claude can then use its internal tools to execute code, run tests, fix bugs, and reply back through the same channel.[48]
The key difference from a typical web chat is persistence. A Claude Code session can remain active in a terminal or on a persistent server, quietly listening. When pinged via Telegram or Discord, it resumes work, runs tasks, and messages back when finished, without the developer needing to reopen a browser or re-establish context.[42]
| Type | Description | Examples |
|---|---|---|
| One-way | Forward alerts, webhooks, or monitoring events for Claude to act on | CI failure alerts, monitoring notifications |
| Two-way | Chat bridges that also expose a reply tool so Claude can send messages back | Telegram bot, Discord bot |
| Permission relay | Two-way channels that can forward tool approval prompts to a remote device | Approving Bash commands from your phone |
Permission relay (available in v2.1.81+) allows developers to approve or deny tool-use requests remotely. When Claude needs permission to run a tool, the prompt is forwarded to the channel. The developer can reply with "yes" or "no" from their phone, and Claude Code applies whichever answer arrives first (local terminal or remote channel).[48]
| Requirement | Detail |
|---|---|
| Claude Code version | v2.1.80 or later |
| Authentication | claude.ai login required (Console/API keys not supported) |
| Runtime | Bun, Node.js, or Deno |
| Enterprise/Team | Must be explicitly enabled by admin |
| Supported platforms | Telegram, Discord (research preview); plugin architecture for expansion |
During the research preview, custom channels require the --dangerously-load-development-channels flag to bypass the approved allowlist. The built-in Telegram and Discord plugins are on the official allowlist.[48]
Channels implement sender allowlisting to prevent prompt injection. The Telegram and Discord plugins use a pairing flow: the user DMs the bot, the bot replies with a pairing code, the user approves it in their Claude Code session, and the platform ID is added to the allowlist. Messages from unrecognized senders are silently dropped.[48]
The Claude Enterprise Analytics API provides programmatic access to engagement and adoption data for Claude and Claude Code usage within an organization. Available to Enterprise plan Primary Owners, the API enables teams to build internal dashboards, track developer activity, and measure the impact of Claude Code on engineering velocity.[49][50]
The API offers five endpoints, all served from the base URL https://api.anthropic.com/v1/organizations/analytics/:
| Endpoint | Path | Description |
|---|---|---|
| User Activity | GET /users | Per-user engagement metrics including conversation counts, messages sent, Claude Code commits, PRs, lines added/removed, sessions, and tool action counts |
| Activity Summary | GET /summaries | Organization-wide daily, weekly, and monthly active user counts, seat utilization, and pending invite counts (up to 31-day range per request) |
| Chat Project Usage | GET /apps/chat/projects | Conversation and user counts broken down by project |
| Skill Usage | GET /skills | Per-skill user counts with breakdowns for Claude chat and Claude Code sessions separately |
| Connector Usage | GET /connectors | MCP/connector usage data across both Claude chat and Claude Code |
A dedicated Claude Code endpoint at /v1/organizations/usage_report/claude_code provides daily aggregated productivity metrics per user, including sessions, lines of code accepted, commits, pull requests, and tool usage.[49]
All data is aggregated per organization, per day. Data is available for dates starting from January 1, 2026, and becomes queryable three days after aggregation (which runs at 10:00 UTC the following day). The API requires an Admin API key (prefixed sk-ant-admin...) with the read:analytics scope. The default rate limit is 60 requests per minute.[49]
In addition to the programmatic API, Claude Code provides visual analytics dashboards:
| Plan | Dashboard URL | Features |
|---|---|---|
| Teams / Enterprise | claude.ai/analytics/claude-code | Usage metrics, contribution metrics with GitHub integration, leaderboard, CSV data export |
| API (Console) | platform.claude.com/claude-code | Usage metrics, spend tracking, per-user team insights |
Contribution metrics (available in public beta for Teams and Enterprise) track PRs and lines of code shipped with Claude Code assistance. When enabled, merged pull requests containing Claude Code-assisted lines are automatically labeled as claude-code-assisted in GitHub. The system uses conservative matching, and only code where there is high confidence in Claude Code's involvement is counted.[50]
Hooks are user-defined shell commands that execute at specific points in Claude Code's lifecycle. Introduced in June 2025 and significantly expanded in later versions, hooks provide deterministic control over agent behavior, ensuring certain actions always happen rather than relying on the LLM to choose to run them.[18][19]
Claude Code supports a comprehensive set of lifecycle events that hooks can target:
| Event | When It Fires |
|---|---|
| SessionStart | When a session begins or resumes |
| UserPromptSubmit | When the user submits a prompt, before Claude processes it |
| PreToolUse | Before a tool call executes (can block the action) |
| PermissionRequest | When a permission dialog appears |
| PostToolUse | After a tool call succeeds |
| PostToolUseFailure | After a tool call fails |
| Notification | When Claude Code sends a notification |
| SubagentStart | When a subagent is spawned |
| SubagentStop | When a subagent finishes |
| Stop | When Claude finishes responding |
| StopFailure | When the turn ends due to an API error (added v2.1.78, March 2026) |
| TeammateIdle | When an agent team teammate is about to go idle |
| TaskCompleted | When a task is being marked as completed |
| InstructionsLoaded | When a CLAUDE.md or rules file is loaded into context |
| ConfigChange | When a configuration file changes during a session |
| WorktreeCreate | When a worktree is created via --worktree or isolation settings |
| WorktreeRemove | When a worktree is being removed |
| PreCompact | Before context compaction |
| PostCompact | After context compaction completes (added v2.1.76, March 2026) |
| Elicitation | When an MCP server requests user input during a tool call (added v2.1.76, March 2026) |
| ElicitationResult | After a user responds to an MCP elicitation (added v2.1.76, March 2026) |
| SessionEnd | When a session terminates |
Hooks come in four types, each suited to different use cases:
| Type | Description | Use Case |
|---|---|---|
| command | Runs a shell command | File formatting, logging, notifications, blocking edits |
| http | POSTs event data to a URL | Audit logging, external service integration |
| prompt | Single-turn LLM evaluation | Judgment-based decisions (e.g., "are all tasks complete?") |
| agent | Multi-turn verification with tool access | Complex verification requiring file inspection or test execution |
Hooks communicate with Claude Code through stdin, stdout, stderr, and exit codes. When an event fires, Claude Code passes event-specific data as JSON to the hook's stdin. The exit code determines the outcome:
Hook configurations are stored in settings files at different scopes:
| Location | Scope | Shareable |
|---|---|---|
~/.claude/settings.json | All projects | No, local to machine |
.claude/settings.json | Single project | Yes, can be committed to repo |
.claude/settings.local.json | Single project | No, gitignored |
| Managed policy settings | Organization-wide | Yes, admin-controlled |
Common hook patterns include auto-formatting code after edits (PostToolUse), blocking modifications to protected files like .env or package-lock.json (PreToolUse), sending desktop notifications when Claude needs input (Notification), re-injecting critical context after compaction (SessionStart), and auditing configuration changes (ConfigChange).[18]
Claude Code supports the Model Context Protocol (MCP), an open standard created by Anthropic that enables AI tools to communicate with external services through standardized tool servers. Claude Code can function as both an MCP server and an MCP client, providing extensive integration capabilities.[8]
MCP connections support three transport modes:
| Transport | Description | Use Case |
|---|---|---|
| stdio | Communicates via stdin/stdout with locally launched processes | Local servers, lowest latency (<5ms) |
| SSE | Server-Sent Events for remote connections | Remote hosted servers |
| HTTP Streamable | Recommended for production cloud deployments | Server-to-server integrations, gradually replacing SSE |
MCP server configuration can be stored in multiple locations depending on scope: .mcp.json in the project directory (version-controlled), .claude/settings.local.json for project-specific settings, or ~/.claude/settings.local.json for user-specific defaults.[20]
When many MCP servers are configured, tool definitions can consume a significant portion of the context window. MCP Tool Search addresses this by dynamically loading tools on-demand instead of preloading all of them, preserving context for actual work.[20]
Added in v2.1.76 (March 2026), MCP elicitation support allows MCP servers to request structured input from the user mid-task via an interactive dialog. The Elicitation and ElicitationResult hooks can intercept and process these responses.[44]
Through MCP, Claude Code can connect to a wide range of external services:
Subagents are specialized AI assistants that run in isolated context windows with custom system prompts, specific tool access, and independent permissions. Introduced in July 2025, this feature enables developers to delegate complex or context-heavy tasks to dedicated agents while preserving the main conversation's context.[15][21]
Each subagent operates in its own context window, separate from the main conversation. When a subagent finishes, only a summary of its results is returned to the main session, keeping verbose output (such as test results or log files) from consuming valuable context. Subagents can be configured at the project level (.claude/agents/) or user level (~/.claude/agents/) using Markdown files with YAML frontmatter that defines their tools, permissions, and system prompts.
Claude Code can dispatch multiple subagents simultaneously when tasks are independent. Parallel execution works best when there are three or more unrelated tasks, no shared state between them, and clear file boundaries with no overlap. For example, one subagent can refactor the frontend while another updates the backend API, and a third writes tests.
Developers can background running subagents by pressing Ctrl+B, allowing them to continue working with Claude on other tasks while the subagent completes its work. Background agents display their status, token usage, and progress, and notify the developer upon completion.[22]
Agent Teams, introduced in v2.1.32 (February 5, 2026) as a research preview, represent a higher-level orchestration feature where multiple independent Claude Code sessions coordinate on shared task lists with direct peer-to-peer communication. One session acts as the team lead, coordinating work and assigning tasks, while teammates work independently in their own context windows and communicate directly with each other.[17]
Agent Teams require the Claude Opus 4.6 model and must be enabled via the environment variable CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1. They are most effective for tasks where parallel exploration adds real value, such as large-scale refactoring across multiple modules, research tasks where different aspects can be investigated simultaneously, and migration projects that touch many independent components.
Because each teammate maintains its own context window, token usage scales with the number of active teammates, making Agent Teams significantly more expensive than single-session workflows.[17]
Released on September 29, 2025, Claude Code 2.0 was the first major version update, designed for longer and more complex autonomous development tasks.[3][4]
Checkpoint System: Claude Code 2.0 introduced automatic checkpoints that save code state before each change. Checkpoints are retained for 30 days and can be restored by pressing Esc twice or using the /rewind command. Three restore modes are available: Chat only (rewind chat history while preserving code changes), Code only (revert file changes while preserving conversation), and Both (complete restoration to the previous session state).[3]
VS Code Extension (GA): The VS Code extension, previously in beta, reached general availability with v2.0. It provides a native graphical chat panel, checkpoint-based undo, @-mention file references, and parallel conversations. Developers can review and edit Claude's plans before accepting them, auto-accept edits, and open multiple conversations in separate tabs.[3][13]
Terminal v2.0 UX: The terminal interface received a significant overhaul with prompt history search via Ctrl+R, improved status displays, enhanced performance with large contexts, and the ability to keep long-running processes like development servers in the background without blocking other operations.[3]
Claude Agent SDK: The Claude Code SDK was renamed to the Claude Agent SDK, reflecting its broader capabilities beyond coding. The SDK provides the same infrastructure that powers Claude Code, including context management, tool ecosystems, advanced permissions, and production essentials like error handling and session management. It is available for both Python and TypeScript.[16]
Version 2.1.0, released in early 2026, introduced infrastructure-level features aimed at developers deploying structured workflows and reusable skills.[5]
Hooks for Agents, Skills, and Slash Commands: Scoped PreToolUse, PostToolUse, and Stop logic gives developers fine-grained control over state management, tool constraints, and audit logging within agent and skill contexts.[5]
Hot Reload for Skills: New or updated skills placed in ~/.claude/skills or .claude/skills become available immediately without restarting sessions, enabling rapid iteration on custom capabilities.[5]
Session Teleportation: The /teleport and /remote-env slash commands allow subscribers to resume and configure remote sessions, moving work between local terminals and the web interface at claude.ai.[5]
Language-Specific Output: A language setting enables workflows that require output in Japanese, Spanish, or other languages, so global teams and multilingual projects no longer need post-processing workarounds.[5]
Following v2.0 and v2.1, Claude Code received rapid updates including:
| Feature | Approximate Date | Description |
|---|---|---|
| Background agents | December 2025 | Run subagents in the background while continuing other work |
| Named sessions | December 2025 | Give sessions descriptive names for easy identification |
.claude/rules/ directory | January 2026 | Modular rule files as an alternative to monolithic CLAUDE.md |
| Prompt suggestions | January 2026 | Context-aware prompt suggestions in the REPL |
| SKILL.md support | January 2026 | Reusable skills defined as Markdown with frontmatter |
| Session forking | January 2026 | Branch a conversation to explore alternatives |
| Cloud handoff | January 2026 | Move sessions between terminal and claude.ai/code |
| Claude Opus 4.6 support | February 2026 | 1M context window, 128K output tokens as default model |
| Agent Teams | February 2026 | Multi-agent coordination with peer-to-peer communication |
| Fast mode | February 2026 | Optimized for quick responses on simple tasks |
| Automatic memories | February 2026 | Claude learns project preferences over time |
| PDF page ranges | February 2026 | Read specific pages from large PDFs |
| Claude Code Security | February 20, 2026 | Vulnerability scanning and patch suggestions[47] |
| Code Review | March 9, 2026 | Multi-agent automated PR review system[41] |
| 1M context for Opus 4.6 | March 13, 2026 | Default for Max, Team, and Enterprise plans[44] |
| MCP elicitation | March 14, 2026 | MCP servers can request structured user input mid-task[44] |
| /effort command | March 14, 2026 | Set model effort level via slash command[44] |
| Line-by-line streaming | March 17, 2026 | Response text streams line-by-line as generated[44] |
| Opus 4.6 output limit increase | March 17, 2026 | Default max output raised to 64K, upper bound to 128K[44] |
| Voice mode | March 2026 | Push-to-talk voice input with /voice command[44] |
| /loop command | March 2026 | Recurring task execution on timed intervals[44] |
| Channels (Telegram, Discord) | March 20, 2026 | Push external messages into Claude Code sessions[42] |
| Permission relay via Channels | March 20, 2026 | Approve tool use remotely from phone[48] |
| Computer use on macOS | March 23, 2026 | Claude can interact with screen, open apps, navigate browsers[45] |
On March 23, 2026, Anthropic announced that Claude Code (alongside Claude Cowork) gained the ability to use the developer's computer directly. This computer use capability allows Claude to point, click, type, navigate applications, and run development tools autonomously on the user's machine.[45]
When enabled, Claude follows a priority hierarchy for completing tasks:
Claude requests permission before accessing each application, and the developer can see what it is doing and stop it at any step. Anthropic implemented automatic scanning to detect prompt injection attempts during computer use sessions.[45]
Computer use integration is available as a research preview for Claude Pro and Claude Max subscribers on macOS. Windows and Linux support has not yet been announced. A companion mobile tool called Dispatch allows developers to instruct Claude from their phone while away from their computer.[45]
On October 20, 2025, Anthropic launched a web-based version of Claude Code, available at claude.ai/code, as a beta research preview for Pro and Max subscribers. The web version runs inside Anthropic's managed sandboxes, where the agent can clone repositories, edit code, run tests, and push validated changes directly to GitHub. Developers can link multiple repositories, describe desired changes or bug fixes, and have Claude Code execute the work through a single interface with parallel execution support.[23]
The web version was later extended to the iOS app, allowing developers to interact with Claude Code on mobile devices.[23]
| Component | Requirement |
|---|---|
| Operating System | macOS 10.15+, Ubuntu 20.04+/Debian 10+, Windows 10+ (via WSL 1/2 or Git for Windows) |
| Hardware | Minimum 4GB RAM (8GB recommended for large codebases) |
| Software | Node.js 18+ and npm |
| Network | Internet connection required (authentication & model inference) |
| Supported Shells | Bash, Zsh, Fish |
| Dependencies | Git, ripgrep (recommended) |
| Availability | Only in Anthropic's supported countries |
The tool is available only in countries and regions supported by Anthropic.[24]
Claude Code can be installed through multiple methods:
npm install -g @anthropic-ai/claude-code
cd your-awesome-project claude
curl -fsSL https://claude.ai/install.sh | bash
curl -fsSL https://claude.ai/install.sh | bash -s latest
curl -fsSL https://claude.ai/install.sh | bash -s 1.0.128
For Windows:
PowerShell: irm https://claude.ai/install.ps1 | iex
CMD: ``` curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd
Post-installation, run `claude doctor` to verify. For Alpine Linux or musl-based systems, install additional dependencies like libgcc, libstdc++, and ripgrep.<sup><a href="#cite_note-24" class="cite-ref">[24]</a></sup>
### Local Installation
After global installation, use `claude migrate-installer` to switch to local mode to avoid permission issues with auto-updates.<sup><a href="#cite_note-24" class="cite-ref">[24]</a></sup>
### Authentication
Authenticate via Claude Console (default for billing), Claude App (for Pro/Max plans), or enterprise platforms like [Amazon Bedrock](/wiki/amazon_bedrock) and Google Cloud Vertex AI. Credentials are stored securely.<sup><a href="#cite_note-24" class="cite-ref">[24]</a></sup><sup><a href="#cite_note-25" class="cite-ref">[25]</a></sup>
## CLAUDE.md Project Context
Claude Code uses a special **CLAUDE.md** file for persistent context and project documentation. This file is automatically loaded when Claude Code starts in a directory and serves as the primary mechanism for communicating project-specific instructions, coding standards, and workflow requirements to the agent.<sup><a href="#cite_note-26" class="cite-ref">[26]</a></sup>
### File Locations and Hierarchy
CLAUDE.md files can be placed at multiple levels, and Claude Code merges them in order of specificity:
| Location | Scope | Version Controlled |
| --- | --- | --- |
| `~/. claude/CLAUDE.md` | Global (all projects) | No |
| `../../CLAUDE.md` | Parent directories (monorepos) | Typically yes |
| `./CLAUDE.md` | Project root | Yes |
| `./.claude/CLAUDE.md` | Project-specific (alternative) | Yes |
### Common Content
A typical CLAUDE.md file includes:
- **Project architecture**: Framework, language, directory structure
- **Coding standards**: Style guidelines, naming conventions, linting rules
- **Build and test commands**: How to run tests, build the project, start dev servers
- **Workflow rules**: Git branch naming, commit message format, PR requirements
- **Custom instructions**: Project-specific behaviors, forbidden patterns, preferred libraries
The `/init` command generates a starter CLAUDE.md file based on the current project structure. Additionally, the `.claude/rules/` directory (introduced January 2026) allows modular rule files as an alternative to a single monolithic CLAUDE.md, making it easier for teams to manage rules across different concerns.<sup><a href="#cite_note-26" class="cite-ref">[26]</a></sup>
## Usage
### Command Syntax
Claude Code supports various command-line options for different use cases:
| Command | Description | Example |
| --- | --- | --- |
| **claude** | Start interactive REPL | **claude** |
| **claude "query"** | Start REPL with initial prompt | **claude "explain this project"** |
| **claude -p "query"** | Query via SDK, then exit | **claude -p "explain this function"** |
| claude -p "query"**** | Process piped content | claude -p "explain"**** |
| **claude -c** | Continue most recent conversation | **claude -c** |
| **claude -c -p "query"** | Continue via SDK | **claude -c -p "Check for type errors"** |
| **claude -r "<session-id>" "query"** | Resume session by ID | **claude -r "abc123" "Finish this PR"** |
| **claude --model** | Select AI model (sonnet/opus) | **claude --model opus** |
| **claude --resume** | Resume from recent sessions | **claude --resume** |
| **claude --continue** | Continue last session | **claude --continue** |
| **claude update** | Update to latest version | **claude update** |
| **claude mcp** | Configure MCP servers | See MCP docs |
### CLI Flags
Additional flags enhance functionality:
| Flag | Description | Example |
| --- | --- | --- |
| **--add-dir** | Add working directories | **claude --add-dir ../apps ../lib** |
| **--allowedTools** | Allow tools without prompt | **claude --allowedTools "Bash(git log:*)" "Read"** |
| **--disallowedTools** | Disallow tools | **claude --disallowedTools "Edit"** |
| **--print**, **-p** | Print response without interactive mode | **claude -p "query"** |
| **--append-system-prompt** | Append to system prompt (with --print) | **claude --append-system-prompt "Custom instruction"** |
| **--output-format** | Output format (text, json, stream-json) | **claude -p --output-format json** |
| **--input-format** | Input format (text, stream-json) | **claude -p --input-format stream-json** |
| **--verbose** | Enable verbose logging | **claude --verbose** |
| **--max-turns** | Limit agentic turns | **claude -p --max-turns 3** |
| **--permission-mode** | Set permission mode | **claude --permission-mode plan** |
| **--dangerously-skip-permissions** | Skip permissions (use with caution) | **claude --dangerously-skip-permissions** |
| **--bare** | Skip hooks, LSP, plugin sync, and skill walks for scripted -p calls (v2.1.81) | **claude --bare -p "query"** |
| **--channels** | Enable channel plugins for external messaging (v2.1.80) | **claude --channels plugin:telegram** |
### Interactive Commands
Within the interactive REPL, users can access various slash commands:
| Command | Description |
| --- | --- |
| **/clear** | Reset context window |
| **/bug** | Report issues directly to Anthropic |
| **/config** | Access configuration settings |
| **/model** | Switch between available models |
| **/status** | Check usage limits and billing |
| **/vim** | Enable Vim keybindings |
| **/terminal-setup** | Configure terminal shortcuts |
| **/rewind** | Restore to previous checkpoint (v2.0+) |
| **/agents** | Create custom subagents |
| **/init** | Generate CLAUDE.md documentation file |
| **/compact** | Summarize conversation to save context |
| **/export** | Export conversation for sharing |
| **/statusline** | Customize status line display |
| **/install-github-app** | Set up GitHub integration |
| **/hooks** | Browse all configured hooks |
| **/teleport** | Resume or configure remote sessions (v2.1+) |
| **/login** | Switch authentication |
| **/logout** | Log out |
| **/voice** | Activate push-to-talk voice mode (March 2026) |
| **/loop** | Run a prompt on a recurring interval (March 2026) |
| **/effort** | Set model effort level (v2.1.76, March 2026) |
| **/branch** | Branch conversation to explore alternatives (renamed from /fork, v2.1.77) |
| **/color** | Set prompt-bar color for session (v2.1.75) |
| **/context** | Show actionable suggestions for context management (v2.1.74) |
### Unix Philosophy Integration
Claude Code follows Unix philosophy principles, allowing integration with existing command-line tools:<sup><a href="#cite_note-9" class="cite-ref">[9]</a></sup>
# Process piped content
tail -f app.log | claude -p "alert me if you see repeated 5xx and suggest fixes"
# Batch annotate files
for file in *.js; do
claude -p "Add JSDoc comments to this file:" < "$file" > "${file}.documented"
done
# Automated workflows
for f in src/**/*.ts; do
claude -p "Add TSDoc to this file:" < "$f" > "${f%.ts}.annotated.ts"
done
## Claude Agent SDK
On September 29, 2025, Anthropic renamed the Claude Code SDK to the Claude Agent SDK, reflecting its broader capabilities beyond coding.<sup><a href="#cite_note-16" class="cite-ref">[16]</a></sup> The SDK provides developers with the same infrastructure that powers Claude Code, including:
### SDK Components
| Component | Description |
| --- | --- |
| Context Management | Automatic compaction and context management |
| Rich Tool Ecosystem | File operations, code execution, web search, and MCP extensibility |
| Advanced Permissions | Fine-grained control over agent capabilities |
| Production Essentials | Built-in error handling, session management, and monitoring |
| Optimized Integration | Automatic prompt caching and performance optimizations |
### Example Implementation
import anyio
from claude_code_sdk import query
async def main():
async for message in query(prompt="What is 2 + 2?"):
print(message)
anyio.run(main)
The SDK is available for Python and TypeScript, enabling developers to build various types of agents including SRE agents, code review agents, legal assistants, and finance advisors.<sup><a href="#cite_note-16" class="cite-ref">[16]</a></sup>
## Pricing and Plans
Claude Code is available through multiple subscription tiers and deployment options:<sup><a href="#cite_note-25" class="cite-ref">[25]</a></sup>
| Plan | Price (USD) | Claude Code Access | Key Features | Best For |
| --- | --- | --- | --- | --- |
| Pro | $20/month ($17/mo annual) | Yes (Sonnet only) | 10-40 prompts every 5 hours; 40-80 hours of Sonnet 4.5 weekly | Light work on small repositories |
| Max 5x Pro | $100/month | Yes (Sonnet + Opus) | 50-200 prompts every 5 hours; 140-280 hours of Sonnet 4.5; 15-35 hours of Opus weekly | Regular use with medium codebases |
| Max 20x Pro | $200/month | Yes (Sonnet + Opus) | 200-800 prompts every 5 hours; 240-480 hours of Sonnet 4.5; 24-40 hours of Opus weekly | Power users with large codebases |
| Team (Standard) | $25/user/month ($30 monthly) | No | Core collaboration, chat, projects | Teams without coding needs |
| Team (Premium) | $150/user/month | Yes | Full Claude Code access, terminal environment | Development teams |
| API | Pay-as-you-go | Yes | $3/$15 per MTok (Sonnet 4.5); $5/$25 per MTok (Opus 4.6) | Enterprise and custom integrations |
| Enterprise | Custom | Yes | SSO, SCIM, priority support, custom contracts | Large organizations |
| Education | Custom | Yes | University-wide access, discounted rates | Academic institutions |
Enterprise customers can also access Claude Code through Amazon Bedrock, Google Cloud Vertex AI, and Microsoft Foundry.<sup><a href="#cite_note-8" class="cite-ref">[8]</a></sup>
### Usage Management
Claude Code implements automatic model switching to prevent users from exhausting their limits too quickly:
- Max 5x users: Automatically switches from Opus to Sonnet at 20% usage
- Max 20x users: Automatically switches from Opus to Sonnet at 50% usage
Users can override this behavior using the `/model` command.<sup><a href="#cite_note-25" class="cite-ref">[25]</a></sup>
## Comparison with Other AI Coding Tools
Claude Code competes in a rapidly evolving market of AI-powered development tools. Each major tool represents a distinct design philosophy: terminal-native agentic (Claude Code), IDE-native (Cursor), plugin/extension-based ([GitHub Copilot](/wiki/github_copilot)), and cloud-delegated ([OpenAI](/wiki/openai) [Codex](/wiki/codex)).<sup><a href="#cite_note-27" class="cite-ref">[27]</a></sup>
### Feature Comparison
| Feature | [Claude Code](/wiki/claude_code) | [Cursor](/wiki/cursor) | [GitHub Copilot](/wiki/github_copilot) | [OpenAI Codex](/wiki/openai_codex) |
| --- | --- | --- | --- | --- |
| **Interface** | Terminal CLI + IDE extensions | Custom VS Code fork | IDE plugin (VS Code, JetBrains, etc.) | ChatGPT web UI + CLI |
| **Primary Model** | Claude Opus 4.6 / Sonnet 4.5 | Multi-model (Claude, GPT, Gemini) | Multi-model (Claude, GPT, Gemini) | GPT-5.3-Codex |
| **Context Window** | Up to 1M tokens | Up to 200K tokens | Varies by model | Up to 1M tokens |
| **Agentic Coding** | Yes (native) | Yes (Composer/Agent mode) | Yes (Copilot coding agent) | Yes (cloud sandboxes) |
| **Multi-file Editing** | Yes | Yes (Composer) | Yes (Copilot Edits) | Yes |
| **Git Integration** | Deep (commits, PRs, merge conflicts) | Basic (via terminal) | Deep (GitHub native) | Yes (PR creation) |
| **Code Completion** | No (agentic only) | Yes (Supermaven/Tab) | Yes (inline suggestions) | No (agentic only) |
| **MCP Support** | Yes (server + client) | Yes (client) | Yes (client) | Limited |
| **Background Agents** | Yes (subagents, agent teams) | Yes (via Background Agent) | Yes (Copilot coding agent) | Yes (cloud-based) |
| **Hooks/Automation** | Yes (22+ event types) | Limited | GitHub Actions integration | Limited |
| **Custom Rules** | CLAUDE.md, .claude/rules/ | .cursorrules | .github/copilot-instructions.md | AGENTS.md |
| **Web Version** | Yes (claude.ai/code) | No (desktop only) | Yes (github.com) | Yes (ChatGPT) |
| **Code Review** | Yes (multi-agent PR review) | No | Yes (Copilot code review) | No |
| **Voice Mode** | Yes (/voice, push-to-talk) | No | No | No |
| **Open Source** | Client is open source | No | No | Partially open |
| **Starting Price** | $20/month (Pro) | $20/month (Pro) | $10/month (Pro) | $20/month (Plus) |
| **Power Tier Price** | $200/month (Max 20x) | $200/month (Ultra) | $39/month (Pro+) | $200/month (Pro) |
### Performance Benchmarks
| Benchmark | Claude Code (Opus 4.6) | Cursor | GitHub Copilot | OpenAI Codex |
| --- | --- | --- | --- | --- |
| SWE-bench Verified | 80.9% | Varies by model | Varies by model | ~80% |
| Developer "Most Loved" (2026) | 46% | 19% | 9% | N/A |
| Startup Adoption Rate | 75% | ~30% | ~40% | ~15% |
| Enterprise Adoption (10K+ employees) | ~35% | ~20% | 56% | ~15% |
Most professional developers in 2026 combine multiple tools: Copilot for inline autocomplete (low cost and ubiquitous), Cursor or Claude Code for complex agentic tasks (depending on IDE vs. terminal preference), and occasionally Codex for autonomous cloud-based work.<sup><a href="#cite_note-27" class="cite-ref">[27]</a></sup>
## IDE Extensions
### Visual Studio Code
The VS Code extension, which reached general availability on September 29, 2025, provides the most polished IDE integration for Claude Code. Key features include:<sup><a href="#cite_note-3" class="cite-ref">[3]</a></sup><sup><a href="#cite_note-13" class="cite-ref">[13]</a></sup>
- **Native graphical chat panel** integrated into the VS Code sidebar
- **Checkpoint-based undo** with visual diff display
- **@-mention file references** with specific line range selection
- **Parallel conversations** in separate tabs or windows
- **Plan preview and editing** before accepting changes
- **Auto-accept mode** for edits as they are made
- **Conversation history** for resuming previous sessions
- **Real-time inline diff view** showing changes as they happen
- **Remote Control bridge** to claude.ai/code (added March 2026)<sup><a href="#cite_note-44" class="cite-ref">[44]</a></sup>
- **AI-generated session tab titles** based on first message (v2.1.79)<sup><a href="#cite_note-44" class="cite-ref">[44]</a></sup>
The extension is available through the VS Code Marketplace and is compatible with VS Code, Cursor, and [Windsurf](/wiki/windsurf) editors.
### JetBrains
The JetBrains plugin, currently in beta, supports IntelliJ IDEA, PyCharm, WebStorm, and other JetBrains IDEs. Rather than providing a full GUI, it acts as a bridge connecting the IDE to the Claude Code CLI tool. The plugin provides a chat experience similar to the VS Code extension, with file references, conversation history, and shared configuration via `~/.claude/settings.json`.<sup><a href="#cite_note-28" class="cite-ref">[28]</a></sup>
### Terminal Integration
Beyond dedicated IDE extensions, Claude Code works natively in any terminal embedded within an IDE. Running `claude` in VS Code's integrated terminal or a JetBrains terminal provides the full CLI experience with automatic detection of the IDE environment.
## GitHub Actions Integration
Claude Code offers an official GitHub Action (`anthropics/claude-code-action`) that brings agentic capabilities directly into CI/CD pipelines. The action can:<sup><a href="#cite_note-14" class="cite-ref">[14]</a></sup>
- Respond to `@claude` mentions in pull request comments and issue discussions
- Automatically implement code changes based on issue descriptions
- Run code review and provide feedback on pull requests
- Execute test suites and fix failures
- Create new pull requests from issue specifications
The action supports multiple authentication methods including direct [Anthropic API](/wiki/anthropic_api), Amazon Bedrock, Google Cloud Vertex AI, and Microsoft Foundry. It is built on top of the Claude Agent SDK.<sup><a href="#cite_note-14" class="cite-ref">[14]</a></sup>
## Performance
Claude Code has demonstrated strong performance on coding benchmarks:
| Benchmark | Model | Score | Notes |
| --- | --- | --- | --- |
| SWE-bench Verified | Claude Opus 4.6 | 80.9% | State-of-the-art as of March 2026<sup><a href="#cite_note-10" class="cite-ref">[10]</a></sup> |
| SWE-bench Verified | Claude Sonnet 4.5 | 77.2% | Average of 10 trials; 82.0% with high-compute setup<sup><a href="#cite_note-4" class="cite-ref">[4]</a></sup> |
| SWE-bench Verified | Claude Opus 4 | 72.5% | State-of-the-art as of May 2025<sup><a href="#cite_note-2" class="cite-ref">[2]</a></sup> |
| SWE-bench Verified | Claude Sonnet 4 | 72.7% | As of May 2025<sup><a href="#cite_note-2" class="cite-ref">[2]</a></sup> |
| OSWorld | Claude Sonnet 4.5 | 61.4% | Real-world computer task benchmark<sup><a href="#cite_note-4" class="cite-ref">[4]</a></sup><sup><a href="#cite_note-8" class="cite-ref">[8]</a></sup> |
| Terminal-bench | Claude Opus 4 | 43.2% | Terminal automation benchmark<sup><a href="#cite_note-2" class="cite-ref">[2]</a></sup> |
| Sustained Performance | Claude Sonnet 4.5 | 30+ hours | Autonomous coding, building 11K-line apps<sup><a href="#cite_note-4" class="cite-ref">[4]</a></sup> |
| Sustained Performance | Claude Opus 4 | 7 hours | Autonomous refactor validated by Rakuten<sup><a href="#cite_note-2" class="cite-ref">[2]</a></sup> |
| Internal Code Editing | Claude Sonnet 4.5 | 0% error rate | Reduced from 9% on Sonnet 4<sup><a href="#cite_note-4" class="cite-ref">[4]</a></sup> |
| Code Review Accuracy | Claude Opus 4.6 | <1% incorrect | Less than 1% of review findings marked incorrect by engineers<sup><a href="#cite_note-46" class="cite-ref">[46]</a></sup> |
| Security Scanning | Claude Opus 4.6 | 500+ vulns found | In production open-source codebases undetected for decades<sup><a href="#cite_note-47" class="cite-ref">[47]</a></sup> |
Industry partners have reported significant improvements in development workflows:
- **Cursor**: Called Claude Opus 4 "state-of-the-art for coding"; Sonnet 4.5 further advances complex changes<sup><a href="#cite_note-2" class="cite-ref">[2]</a></sup><sup><a href="#cite_note-4" class="cite-ref">[4]</a></sup>
- **Replit**: Reported "dramatic advancements for complex changes across multiple files"<sup><a href="#cite_note-2" class="cite-ref">[2]</a></sup>
- **GitHub**: Introduced Claude Sonnet 4.5 as the model powering GitHub Copilot coding agent<sup><a href="#cite_note-29" class="cite-ref">[29]</a></sup>
- **Sourcegraph**: Described it as "substantial leap in software development"<sup><a href="#cite_note-2" class="cite-ref">[2]</a></sup>
- **Augment Code**: Higher success rates in complex tasks for Sonnet 4.5<sup><a href="#cite_note-4" class="cite-ref">[4]</a></sup>
- **iGent**: Excellence in autonomous app development<sup><a href="#cite_note-4" class="cite-ref">[4]</a></sup>
- **Manus**: Improved instruction following and outputs<sup><a href="#cite_note-4" class="cite-ref">[4]</a></sup>
- **Block**: Boosts code quality in agents<sup><a href="#cite_note-4" class="cite-ref">[4]</a></sup>
- **Cognition**: Handles complex challenges better<sup><a href="#cite_note-4" class="cite-ref">[4]</a></sup>
## Revenue and Market Impact
Claude Code has been Anthropic's fastest-growing product since its launch. The tool went from zero revenue to over $1 billion in annualized billings within approximately six months of launch, and reached $2.5 billion in annualized revenue by February 2026.<sup><a href="#cite_note-6" class="cite-ref">[6]</a></sup><sup><a href="#cite_note-12" class="cite-ref">[12]</a></sup>
### Revenue Milestones
| Date | Milestone |
| --- | --- |
| February 2025 | Launch (research preview, $0 revenue) |
| May 2025 | General availability |
| November 2025 | $1 billion annualized run rate |
| January 2026 | Business subscriptions begin rapid acceleration (4x growth in 6 weeks) |
| February 2026 | $2.5 billion annualized run rate |
### Contribution to Anthropic
Claude Code accounts for more than half of all enterprise spending on Anthropic products. As of February 2026, Anthropic's overall annualized revenue reached $14 billion, growing over 10x annually for three consecutive years. More than 500 customers spend over $1 million annually, up from roughly a dozen two years earlier. Eight of the ten largest companies on the Fortune 10 list are Claude customers.<sup><a href="#cite_note-6" class="cite-ref">[6]</a></sup><sup><a href="#cite_note-12" class="cite-ref">[12]</a></sup>
Anthropic closed a $30 billion Series G funding round on February 12, 2026, at a $380 billion post-money valuation, making it the second-largest private tech funding round ever. Investors included Coatue, Singapore's GIC sovereign wealth fund, Microsoft, [Nvidia](/wiki/nvidia), and others.<sup><a href="#cite_note-12" class="cite-ref">[12]</a></sup>
### Developer Adoption
According to a Pragmatic Engineer survey of 15,000 developers in February 2026, Claude Code received a 46% "most loved" rating, compared to 19% for Cursor and 9% for GitHub Copilot. Among startups, Claude Code has a 75% adoption rate, with no other AI coding tool approaching that level among small companies. However, at enterprises with 10,000+ employees, GitHub Copilot leads with 56% adoption.<sup><a href="#cite_note-7" class="cite-ref">[7]</a></sup>
## Version History
| Date | Version/Release | Description |
| --- | --- | --- |
| March 2023 | Initial Claude | First Claude model released<sup><a href="#cite_note-2" class="cite-ref">[2]</a></sup> |
| February 24, 2025 | Claude 3.7 Sonnet | Released with Claude Code beta research preview<sup><a href="#cite_note-1" class="cite-ref">[1]</a></sup> |
| April 18, 2025 | Best Practices | Published Claude Code best practices guide<sup><a href="#cite_note-26" class="cite-ref">[26]</a></sup> |
| May 22, 2025 | Claude 4 GA | Claude Opus 4 and Sonnet 4 released; Claude Code announced as Generally Available<sup><a href="#cite_note-2" class="cite-ref">[2]</a></sup> |
| May 23, 2025 | Cloud Integration | Extended availability to AWS Bedrock and Google Vertex AI<sup><a href="#cite_note-8" class="cite-ref">[8]</a></sup> |
| June 2025 | IDE Extensions | VS Code and JetBrains beta extensions released<sup><a href="#cite_note-2" class="cite-ref">[2]</a></sup> |
| June 26, 2025 | Desktop Extensions | One-click MCP server installation for browsers<sup><a href="#cite_note-30" class="cite-ref">[30]</a></sup> |
| June 30, 2025 | Hooks Support | Claude Code hooks support added<sup><a href="#cite_note-19" class="cite-ref">[19]</a></sup> |
| July 4, 2025 | Subagents | Custom subagents feature released<sup><a href="#cite_note-21" class="cite-ref">[21]</a></sup> |
| August 2025 | Rate Limits | New weekly rate limits introduced for Pro and Max plans<sup><a href="#cite_note-31" class="cite-ref">[31]</a></sup> |
| September 29, 2025 | Claude Code 2.0 | Checkpoints, VS Code extension (GA), terminal v2.0, Claude Agent SDK released<sup><a href="#cite_note-3" class="cite-ref">[3]</a></sup> |
| September 29, 2025 | [Claude Sonnet 4.5](/wiki/claude_sonnet_4_5) | New default model with 30+ hour autonomous operation capability<sup><a href="#cite_note-4" class="cite-ref">[4]</a></sup> |
| October 20, 2025 | Claude Code on Web | Web-based version launched at claude.ai/code for Pro and Max subscribers<sup><a href="#cite_note-23" class="cite-ref">[23]</a></sup> |
| Early 2026 | Claude Code 2.1.0 | Hooks for agents/skills, hot reload, session teleportation, language output<sup><a href="#cite_note-5" class="cite-ref">[5]</a></sup> |
| February 5, 2026 | Agent Teams | Multi-agent coordination feature released as research preview (v2.1.32)<sup><a href="#cite_note-17" class="cite-ref">[17]</a></sup> |
| February 10, 2026 | [Claude Opus 4.6](/wiki/claude_opus_4_6) | 1M context, 128K output tokens; becomes default model for Claude Code<sup><a href="#cite_note-10" class="cite-ref">[10]</a></sup> |
| February 20, 2026 | Claude Code Security | Vulnerability scanning and patch suggestions (limited research preview)<sup><a href="#cite_note-47" class="cite-ref">[47]</a></sup> |
| March 9, 2026 | Code Review | Multi-agent automated PR review for Team and Enterprise (research preview)<sup><a href="#cite_note-41" class="cite-ref">[41]</a></sup> |
| March 13, 2026 | v2.1.75 | 1M context window default for Opus 4.6 on Max/Team/Enterprise<sup><a href="#cite_note-44" class="cite-ref">[44]</a></sup> |
| March 14, 2026 | v2.1.76 | MCP elicitation, /effort command, PostCompact hook, session quality survey<sup><a href="#cite_note-44" class="cite-ref">[44]</a></sup> |
| March 17, 2026 | v2.1.77-v2.1.78 | Opus 4.6 output limit raised to 64K/128K, line-by-line streaming, StopFailure hook<sup><a href="#cite_note-44" class="cite-ref">[44]</a></sup> |
| March 19, 2026 | v2.1.79-v2.1.80 | Channels (research preview), /voice improvements, /remote-control for VS Code<sup><a href="#cite_note-44" class="cite-ref">[44]</a></sup> |
| March 20, 2026 | v2.1.81 | --bare flag, --channels permission relay, voice mode fixes<sup><a href="#cite_note-44" class="cite-ref">[44]</a></sup> |
| March 23, 2026 | Computer Use | Claude Code gains macOS computer use capability (research preview)<sup><a href="#cite_note-45" class="cite-ref">[45]</a></sup> |
## Integration Capabilities
### IDE Integration
Claude Code integrates with major IDEs through dedicated extensions:
- **Visual Studio Code**: Native extension (generally available as of September 2025) with inline edit display, dedicated sidebar panel, and real-time changes<sup><a href="#cite_note-3" class="cite-ref">[3]</a></sup><sup><a href="#cite_note-13" class="cite-ref">[13]</a></sup>
- **JetBrains**: Beta extension with inline edit display, integrated via AI chat and JetBrains AI subscription<sup><a href="#cite_note-28" class="cite-ref">[28]</a></sup>
Installation is available through running Claude Code in the IDE terminal or via extension marketplaces.<sup><a href="#cite_note-3" class="cite-ref">[3]</a></sup>
### Development Platform Integration
| Platform | Integration Type | Capabilities |
| --- | --- | --- |
| GitHub/GitLab | Full workflow | Issues, PRs, commits, code review, @claude mentions |
| GitHub Actions | Background tasks | Automated CI/CD workflows, official Claude Code Action<sup><a href="#cite_note-14" class="cite-ref">[14]</a></sup> |
| Amazon Bedrock | API Provider | Enterprise deployment |
| Google Vertex AI | API Provider | Enterprise deployment |
| Microsoft Foundry | API Provider | Enterprise deployment |
| [GitHub Copilot](/wiki/github_copilot) | Model Integration | Claude Sonnet 4.5 available in Copilot<sup><a href="#cite_note-29" class="cite-ref">[29]</a></sup> |
| Telegram | Channels (research preview) | Two-way messaging, permission relay<sup><a href="#cite_note-42" class="cite-ref">[42]</a></sup> |
| Discord | Channels (research preview) | Two-way messaging, permission relay<sup><a href="#cite_note-42" class="cite-ref">[42]</a></sup> |
## Best Practices
### Context Management
Claude Code uses a special **CLAUDE.md** file for persistent context and project documentation. This file can contain:<sup><a href="#cite_note-26" class="cite-ref">[26]</a></sup>
- Project-specific instructions and conventions
- Repository etiquette and coding standards
- Developer environment setup requirements
- Custom commands and workflows
- Project architecture documentation
The file is automatically loaded when Claude Code starts in a directory and can be placed at:
- Project root (checked into version control)
- Parent directories (for monorepos)
- User home directory (~/.claude/CLAUDE.md) for global settings
### Custom Commands
Users can create custom slash commands by placing Markdown files in the **.claude/commands/** directory. These commands become available as reusable prompts within Claude Code sessions and can accept arguments.<sup><a href="#cite_note-26" class="cite-ref">[26]</a></sup><sup><a href="#cite_note-33" class="cite-ref">[33]</a></sup>
### Workflow Patterns
Recommended workflow patterns include:<sup><a href="#cite_note-26" class="cite-ref">[26]</a></sup>
1. Read relevant files and context first without writing code
2. Use subagents for complex problems to preserve context
3. Create a plan before implementing changes
4. Use checkpoints before major edits
5. Clear context between unrelated tasks
6. Monitor usage with `/status` command
## Limitations
As of early 2026, Claude Code has several documented limitations:<sup><a href="#cite_note-8" class="cite-ref">[8]</a></sup>
- Potential for AI-generated mistakes in responses
- Tool execution reliability requires enhancement
- Limited support for very long-running commands
- Terminal rendering capability issues
- [Context window](/wiki/context_window) can fill with irrelevant conversation during extended sessions
- Performance can degrade with accumulated irrelevant content
- OS/platform detection problems in WSL
- Potential npm permission errors
- Node.js conflicts in WSL environments
- Difficulties handling very long pasted content
- VS Code terminal truncation of long pastes
- Usage limits based on subscription; heavy users may hit caps sooner with large codebases or Opus
- Agent Teams consume significantly more tokens than single sessions
- Computer use is limited to macOS in research preview (no Windows or Linux support yet)
- Channels require claude.ai login and do not support API key authentication
Known technical issues include OS detection problems in certain WSL environments and difficulties handling complex terminal UI elements.<sup><a href="#cite_note-24" class="cite-ref">[24]</a></sup>
## Data Privacy
Anthropic updated its consumer privacy terms in late August through September 2025. For Claude Code when used via Free/Pro/Max consumer accounts:
- Users can choose whether chats/coding sessions are used to train models. If enabled, retention is up to 5 years; if disabled, retention is up to 30 days. (These settings apply to new or resumed chats/sessions only.)<sup><a href="#cite_note-34" class="cite-ref">[34]</a></sup><sup><a href="#cite_note-35" class="cite-ref">[35]</a></sup>
- These consumer policies do **not** apply to commercial/government/education contracts or API use via providers like Amazon Bedrock and Vertex AI<sup><a href="#cite_note-34" class="cite-ref">[34]</a></sup>
- User feedback is used for improvements but **not** for generative model training<sup><a href="#cite_note-8" class="cite-ref">[8]</a></sup>
- Feedback transcripts are stored for only 30 days<sup><a href="#cite_note-8" class="cite-ref">[8]</a></sup>
- Limited retention periods with restricted access to session data<sup><a href="#cite_note-8" class="cite-ref">[8]</a></sup>
- Compliance with Anthropic's commercial [Terms](/wiki/terms) of Service<sup><a href="#cite_note-8" class="cite-ref">[8]</a></sup>
- Optional telemetry can be disabled; environment variables allow opt-out<sup><a href="#cite_note-36" class="cite-ref">[36]</a></sup>
- Local-first approach with no cloud storage of code<sup><a href="#cite_note-37" class="cite-ref">[37]</a></sup>
- Code Review is not available for organizations with Zero Data Retention enabled<sup><a href="#cite_note-41" class="cite-ref">[41]</a></sup>
## Reception
Claude Code has received positive reception from the developer community. According to the Pragmatic Engineer survey of 15,000 developers conducted in February 2026, Claude Code earned a 46% "most loved" rating, the highest of any AI coding tool. The tool has been praised for its deep codebase understanding, ability to perform complex multi-file refactoring tasks, and its terminal-native design that fits into existing developer workflows.<sup><a href="#cite_note-7" class="cite-ref">[7]</a></sup>
73% of engineering teams now use AI coding tools daily (up from 41% in 2025), and Claude Code is the most-used tool for complex coding tasks according to the same survey. Among startups, adoption has reached 75%, the highest of any AI coding tool in that segment.<sup><a href="#cite_note-7" class="cite-ref">[7]</a></sup>
Industry analysts have noted that Claude Code represents a shift from simple code completion to truly agentic development assistance. The introduction of checkpoints and autonomous operation capabilities in version 2.0 has been particularly well-received by power users who require extended coding sessions. The subsequent addition of Agent Teams in early 2026 further demonstrated Anthropic's vision for multi-agent software development.<sup><a href="#cite_note-38" class="cite-ref">[38]</a></sup>
The March 2026 launch of Code Review and Claude Code Security expanded Claude Code's scope beyond writing code into reviewing and securing it. The Code Review feature's multi-agent approach, where parallel agents independently analyze PRs and then cross-verify findings, was noted as a departure from single-pass review tools. Security researchers have praised Claude Code Security's ability to find vulnerabilities that traditional static analysis tools miss, though Anthropic acknowledged the dual-use risks of the same capabilities.<sup><a href="#cite_note-41" class="cite-ref">[41]</a></sup><sup><a href="#cite_note-47" class="cite-ref">[47]</a></sup>
Community resources have emerged around Claude Code, including the awesome-claude-code repository for slash-commands and guides.<sup><a href="#cite_note-39" class="cite-ref">[39]</a></sup> A Claude Code CLI Cheatsheet has been published to help developers maximize their usage.<sup><a href="#cite_note-40" class="cite-ref">[40]</a></sup>
## See also
- [Claude](/wiki/claude)
- [Anthropic](/wiki/anthropic)
- [AI pair programming](/wiki/ai_pair_programming)
- [GitHub Copilot](/wiki/github_copilot)
- [Model Context Protocol](/wiki/model_context_protocol)
- [Cursor](/wiki/cursor)
- [Replit](/wiki/replit)
- [OpenAI Codex](/wiki/openai_codex)
- [Vibe Coding](/wiki/vibe_coding)
- [SWE-bench](/wiki/swe-bench)
- [Claude Opus 4.6](/wiki/claude_opus_4_6)
- [Claude Sonnet 4.5](/wiki/claude_sonnet_4_5)
## External links
- [Official Claude Code website](https://www.anthropic.com/claude-code)
- [Claude Code documentation](https://code.claude.com/docs/en)
- [Claude Code GitHub repository](https://github.com/anthropics/claude-code)
- [Claude Code on npm](https://www.npmjs.com/package/@anthropic-ai/claude-code)
- [Claude Code VS Code Extension](https://marketplace.visualstudio.com/items?itemName=anthropic.claude-code)
- [Claude Code community resources](https://claudelog.com)
- [Claude Code Hooks Guide](https://code.claude.com/docs/en/hooks-guide)
- [Claude Code GitHub Action](https://github.com/anthropics/claude-code-action)
- [Claude Code Channels Reference](https://code.claude.com/docs/en/channels-reference)
- [Claude Code Analytics Dashboard](https://code.claude.com/docs/en/analytics)
## References
<ol class="references-list">
<li id="cite_note-1">Anthropic. "Introducing Claude 3.7 Sonnet." Anthropic Blog, February 24, 2025.</li>
<li id="cite_note-2">Anthropic. "Introducing Claude 4." Anthropic Blog, May 22, 2025.</li>
<li id="cite_note-3">Anthropic. "Claude Code 2.0." Anthropic Blog, September 29, 2025.</li>
<li id="cite_note-4">Anthropic. "Introducing Claude Sonnet 4.5." Anthropic Blog, September 29, 2025.</li>
<li id="cite_note-5">VentureBeat. "Claude Code 2.1.0 arrives with smoother workflows and smarter agents." VentureBeat, 2026.</li>
<li id="cite_note-6">NxCode. "Anthropic Hits $380B Valuation: $30B Funding, Super Bowl Ads, and Claude Code's $2.5B Revenue." NxCode, February 2026.</li>
<li id="cite_note-7">Developer Survey 2026. "AI Coding Tool Adoption Hits 73%." Pragmatic Engineer Survey, February 2026.</li>
<li id="cite_note-8">Anthropic. "Claude Code Documentation." docs.anthropic.com.</li>
<li id="cite_note-9">Anthropic. "Claude Code follows the Unix philosophy." Claude Code Best Practices.</li>
<li id="cite_note-10">Anthropic. "Introducing Claude Opus 4.6." Anthropic Blog, February 2026.</li>
<li id="cite_note-11">NxCode. "Best AI for Coding in 2026: 10 Tools Ranked by Real-World Performance." NxCode, 2026.</li>
<li id="cite_note-12">CNBC. "Anthropic closes $30 billion funding round as cash keeps flowing into top AI startups." CNBC, February 12, 2026.</li>
<li id="cite_note-13">Anthropic. "Use Claude Code in VS Code." Claude Code Documentation.</li>
<li id="cite_note-14">GitHub. "Claude Code Action Official." GitHub Marketplace.</li>
<li id="cite_note-15">Anthropic. "Create custom subagents." Claude Code Documentation.</li>
<li id="cite_note-16">Anthropic. "Claude Agent SDK." Claude Code Documentation, September 29, 2025.</li>
<li id="cite_note-17">Anthropic. "Orchestrate teams of Claude Code sessions." Claude Code Documentation.</li>
<li id="cite_note-18">Anthropic. "Automate workflows with hooks." Claude Code Documentation.</li>
<li id="cite_note-19">Claude Code Changelog. "Hooks Support." June 30, 2025.</li>
<li id="cite_note-20">Anthropic. "Connect Claude Code to tools via MCP." Claude Code Documentation.</li>
<li id="cite_note-21">Claude Code Changelog. "Subagents." July 4, 2025.</li>
<li id="cite_note-22">Claude Code Documentation. "Claude Code Async: Background Agents & Parallel Tasks."</li>
<li id="cite_note-23">TechCrunch. "Anthropic brings Claude Code to the web." TechCrunch, October 20, 2025.</li>
<li id="cite_note-24">Anthropic. "Claude Code Installation and System Requirements." Claude Code Documentation.</li>
<li id="cite_note-25">Anthropic. "Plans & Pricing." claude.com/pricing.</li>
<li id="cite_note-26">Anthropic. "Claude Code Best Practices." Anthropic Blog, April 18, 2025.</li>
<li id="cite_note-27">adventureppc.com. "Claude Code vs Cursor vs GitHub Copilot: The Definitive AI Coding Tool Comparison for 2026."</li>
<li id="cite_note-28">JetBrains Marketplace. "Claude Code [Beta] Plugin for JetBrains IDEs."</li>
<li id="cite_note-29">GitHub. "Claude Sonnet 4.5 in GitHub Copilot." GitHub Blog, 2025.</li>
<li id="cite_note-30">Claude Code Changelog. "Desktop Extensions." June 26, 2025.</li>
<li id="cite_note-31">Claude Code Changelog. "Rate Limits." August 2025.</li>
<li id="cite_note-32">pasqualepillitteri.it. "Claude Code March 2026: All Updates from /loop to Voice Mode."</li>
<li id="cite_note-33">Anthropic. "Custom slash commands." Claude Code Documentation.</li>
<li id="cite_note-34">Anthropic. "Privacy Terms Update." September 2025.</li>
<li id="cite_note-35">Claude Help Center. "Privacy and Data Usage."</li>
<li id="cite_note-36">Anthropic. "Telemetry and opt-out options." Claude Code Documentation.</li>
<li id="cite_note-37">Anthropic. "Claude Code local-first approach." Claude Code Documentation.</li>
<li id="cite_note-38">Industry analysis based on multiple sources including SaaStr, TechCrunch, and VentureBeat coverage of Claude Code, 2025-2026.</li>
<li id="cite_note-39">GitHub. "awesome-claude-code repository."</li>
<li id="cite_note-40">"Claude Code CLI Cheatsheet." Community documentation.</li>
<li id="cite_note-41">Anthropic. "Code Review for Claude Code." claude.com/blog/code-review, March 9, 2026. Also: code.claude.com/docs/en/code-review.</li>
<li id="cite_note-42">VentureBeat. "Anthropic just shipped an <a href="/wiki/openclaw">OpenClaw</a> killer called Claude Code Channels, letting you message it over Telegram and Discord." VentureBeat, March 2026.</li>
<li id="cite_note-43">TechCrunch. "Anthropic launches code review tool to check flood of AI-generated code." TechCrunch, March 9, 2026.</li>
<li id="cite_note-44">Anthropic. "Claude Code Changelog." code.claude.com/docs/en/changelog. Versions v2.1.73 through v2.1.81, March 2026.</li>
<li id="cite_note-45">Engadget. "Claude Code and Cowork can now use your computer." Engadget, March 23, 2026. Also: 9to5Mac, SiliconANGLE, March 2026.</li>
<li id="cite_note-46">Anthropic. "Code Review for Claude Code (Blog)." claude.com/blog/code-review, March 9, 2026.</li>
<li id="cite_note-47">Anthropic. "Claude Code Security." anthropic.com/news/claude-code-security, February 20, 2026. Also: The Hacker News, VentureBeat, CyberScoop, February 2026.</li>
<li id="cite_note-48">Anthropic. "Channels reference." code.claude.com/docs/en/channels-reference.</li>
<li id="cite_note-49">Claude Help Center. "Claude Enterprise Analytics API reference guide." support.claude.com.</li>
<li id="cite_note-50">Anthropic. "Track team usage with analytics." code.claude.com/docs/en/analytics.</li>
</ol>