Claude Code
Last reviewed
Sources
60 citations
Review status
Source-backed
Revision
v13 ยท 15,228 words
Improve this article
Add missing citations, update stale details, or suggest a clearer explanation.
Suggest edit
CtrlK
Last reviewed
Sources
60 citations
Review status
Source-backed
Revision
v13 ยท 15,228 words
Add missing citations, update stale details, or suggest a clearer explanation.
See also: Claude
Claude Code is an AI-powered command-line tool for agentic coding developed by Anthropic that lets developers delegate software tasks to Claude directly from their terminal. 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 became Anthropic's fastest-growing product, going from zero to a $1 billion annualized run rate in roughly six months and reaching over $2.5 billion in annualized revenue by February 2026.[1][2][6] Anthropic describes Claude Code as "a command line tool for agentic coding" that "can read your files, run commands, make changes, and autonomously work through problems while you watch, redirect, or step away entirely."[26]
Unlike code-completion assistants that offer inline suggestions, Claude Code takes an agentic approach: given a task in plain English, it reads files, searches the codebase, writes and edits code, runs commands, and iterates on its own output from a terminal-based REPL (Read-Eval-Print Loop). In a Pragmatic Engineer survey of 15,000 developers conducted between January 27 and February 17, 2026, Claude Code earned a 46% "most loved" rating, the highest of any AI coding tool, compared with 19% for Cursor and 9% for GitHub Copilot.[7]
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]
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]
In April 2026, Anthropic released Claude Opus 4.7, which became the new default model for Claude Code, alongside major UX upgrades including a native CLI binary, the NO_FLICKER rendering engine, Focus View, the /ultraplan cloud planning command, vim visual modes, named themes, and the /powerup interactive learning system. The company also published a transparency postmortem on April 23, 2026 explaining three separate bugs that had degraded Claude Code quality between March 4 and April 20, 2026, and reset usage limits for all subscribers as a remediation.[51][52][53]
In May 2026, Anthropic shipped Agent View and the /goal command in v2.1.139, giving developers a unified dashboard for managing multiple background sessions and a way to set outcome-based completion conditions that Claude works toward autonomously across turns. Fast mode (toggled via /fast) reached Opus 4.7 as its default model on May 14, 2026, delivering roughly 2.5x faster responses at higher per-token cost without changing model quality.[56] On May 28, 2026, Claude Opus 4.8 became the new default model; Anthropic states that "Opus 4.8 is around four times less likely than its predecessor to allow flaws in code it has written to pass unremarked," failing to flag flaws in its own code in 3.7% of cases versus 19.7% for Opus 4.7.[57]
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. As of May 2026, Claude Opus 4.8 is the default model for Claude Code on paid plans, having superseded Claude Opus 4.7, which served as default from April through late May 2026, and Claude Opus 4.6 (model ID: claude-opus-4-6-20260210) before that.[10][51][57] Opus 4.7 advanced the state of the art on agentic coding, multidisciplinary reasoning, scaled tool use, and computer use, scoring approximately 70% on CursorBench versus 58% for Opus 4.6, and was the first Claude model with high-resolution image support up to 2,576 pixels on the long edge (about 3.75 megapixels).[51] Opus 4.8 advanced further, scoring 69.2% on agentic coding (SWE-bench Pro) versus 64.3% for Opus 4.7.[57] Users on Max subscriptions have access to Opus models 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, with Opus 4.7 and Opus 4.8 posting further gains on the most difficult tasks.[10][11][51][57]
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)
/goal - Set an autonomous completion condition (May 2026)
/fast - Toggle Fast Mode for 2.5x faster Opus responses (May 2026)
claude agents - Open Agent View, a dashboard for all running sessions (May 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 |
| CwdChanged | When the working directory changes (added v2.1.83, April 2026) |
| FileChanged | When a watched file changes during a session (added v2.1.83, April 2026) |
| TaskCreated | When a new task is created (added v2.1.84, April 2026) |
| PermissionDenied | When auto-mode rejects a tool request (added v2.1.90, April 2026) |
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 |
| mcp_tool | Invokes a configured MCP tool directly from a hook (April 2026) | Routing event payloads through enterprise systems without a shell shim |
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] |
| /claude-api skill, 10 new voice languages | April 2026 (v2.1.69) | Built-in API/SDK skill; speech-to-text reaches 20 languages total[52] |
| /loop scheduling improvements | April 2026 (v2.1.71) | Scheduled, repeated prompt and command execution refined[52] |
| /plan parameters, /copy w, ExitWorktree | April 2026 (v2.1.72) | Plan descriptions, direct file writes, sub-agent worktree cleanup[52] |
| Branch performance, allowRead sandbox | April 2026 (v2.1.77) | 45% faster on branch-heavy sessions; new sandbox file system setting[52] |
| Memory reduction | April 2026 (v2.1.80) | Roughly 80MB startup memory savings[52] |
| CwdChanged and FileChanged hooks | April 2026 (v2.1.83) | Hook events for working-directory and file-system changes[52] |
| PowerShell tool, linear streaming, TaskCreated hook | April 2026 (v2.1.84) | Windows PowerShell tool preview; smoother text streaming[52] |
| Scrolling engine TS rewrite | April 2026 (v2.1.85) | Migrated scrolling engine from WASM to TypeScript[52] |
| NO_FLICKER rendering, /powerup | April 2026 (v2.1.89-90) | Alt-screen buffered rendering engine; interactive learning system[52] |
| Focus View, PermissionDenied hook | April 2026 (v2.1.90) | Ctrl+O focus toggle; new auto-mode rejection hook[52] |
| /ultraplan research preview | April 2026 (v2.1.91) | Cloud-based plan-mode session with browser review interface[54] |
| Bedrock setup wizard, /release-notes | April 2026 (v2.1.92) | Interactive AWS Bedrock onboarding and version selector[52] |
| Composite Bash hardening, Focus refinements | April 2026 (v2.1.97) | Stronger sandboxing of compound shell commands[52] |
| PID namespace isolation, Vertex AI wizard, Monitor tool | April 2026 (v2.1.98) | Linux subprocess isolation; background script monitor[52] |
| /team-onboarding, OS CA trust | April 2026 (v2.1.101) | Auto-generated team guides; trusts OS-level certificate stores[52] |
| Claude Opus 4.7 launch | April 16, 2026 | New default model; xhigh effort default for Opus 4.7, high for others[51] |
| Native CLI binary, /loop Remote Control, Windows Ctrl+Backspace | April 17, 2026 (v2.1.113) | CLI moved from bundled JavaScript runtime to native binary[55] |
| Permission dialog crash fix | April 19, 2026 (v2.1.114) | Resolved teammate tool-request crash in shared environments[55] |
| Auto-mode Sonnet fallback | April 17, 2026 (v2.1.115) | Silently falls back to Sonnet during transient Opus unavailability[55] |
| /resume rewrite, inline thinking progress | April 21-22, 2026 (v2.1.116) | 67% faster /resume; smoother fullscreen scroll in VS Code[55] |
| Concurrent MCP startup, persistent /model selection | April 22, 2026 (v2.1.117) | Subsecond startup; OAuth refresh fixed; graceful WebFetch timeouts[55] |
| April 23 transparency postmortem | April 23, 2026 | Anthropic explained three bugs degrading quality; reset usage limits[53] |
| Vim visual modes, /usage, themes, hook MCP tools | April 2026 | v and V visual modes; merged usage tab; named themes; mcp_tool hooks[55] |
| DISABLE_UPDATES env var | April 2026 | Blocks all update paths including manual claude update[55] |
Claude Code released roughly twenty patch versions in May 2026, from v2.1.118 through v2.1.143. Three additions changed how developers structure long-running work: Agent View, the /goal command, and a generally available Fast Mode toggle. The same window also expanded hook semantics, MCP server resilience, and plugin tooling.[56]
Agent View, introduced in v2.1.139 on May 12, 2026 as a research preview, is a single dashboard listing every Claude Code session running, waiting on input, or finished. Developers open it by running claude agents at the terminal. From inside any session, the new /bg slash command moves the current conversation to the background and returns to the dashboard, where typing a prompt and pressing Enter starts a new background session in parallel. Background sessions draw down the subscriber's usage quota at the same rate as interactive sessions, so five parallel sessions consume the quota five times faster.[56]
Also shipped in v2.1.139, the /goal command sets an outcome-based completion condition and lets Claude work toward it across multiple turns without per-turn user prompts. A live overlay shows elapsed time, turn count, and current token usage. /goal works in interactive mode, in -p print mode, and through the Remote Control bridge to the VS Code extension. Execution stops when the completion condition is met or when Claude reports that it is stuck.[56]
Fast Mode reached general availability in May 2026. Toggled with /fast, it switches Claude Opus to an API configuration that prioritizes speed over cost efficiency, delivering responses roughly 2.5x faster at higher per-token cost. The capability requires Claude Code v2.1.36 or later and is available only on Opus 4.6 and Opus 4.7. On May 14, 2026, Opus 4.7 became the default model used by /fast.[56]
| Change | Version | Detail |
|---|---|---|
| Hook input fields | v2.1.139+ | PostToolUse and PostToolUseFailure hooks receive a duration_ms field for tool execution time |
| Hook output replacement | v2.1.139+ | PostToolUse hooks can replace tool output for all tools via hookSpecificOutput.updatedToolOutput (previously MCP-only) |
| terminalSequence field | v2.1.141 | Hooks can emit desktop notifications, window titles, and bells without a controlling terminal |
| Parallel MCP reconfiguration | v2.1.139+ | MCP server reconfiguration connects servers in parallel instead of serially |
| MCP retry on startup error | v2.1.139+ | Transient startup errors trigger up to 3 automatic reconnect attempts |
| MCP tool counts in /mcp | v2.1.139+ | /mcp displays per-server tool counts and flags servers that connected with zero tools |
| MCP OAuth refresh fix | v2.1.139+ | Refresh tokens are now persisted so remote MCP servers no longer require daily re-authentication |
| Plugin dependencies | v2.1.143 | claude plugin disable refuses when another enabled plugin depends on the target; enable force-installs transitive dependencies |
| Plugin cost preview | v2.1.143 | /plugin marketplace browse pane shows projected per-turn and per-invocation context cost |
| worktree.bgIsolation: "none" | v2.1.143 | Background sessions can edit the working copy directly without EnterWorktree |
| PowerShell ExecutionPolicy | v2.1.143 | Tool now passes -ExecutionPolicy Bypass; opt out with CLAUDE_CODE_POWERSHELL_RESPECT_EXECUTION_POLICY=1 |
| Rewind: summarize to here | v2.1.141 | Rewind menu can compress earlier turns while keeping recent context intact |
| Subagent cache | v2.1.139+ | Subagent progress summaries hit the prompt cache, cutting cache_creation token cost roughly 3x; idle subagents stop re-summarizing static transcripts |
| ANTHROPIC_WORKSPACE_ID | v2.1.141 | New environment variable for workload identity federation |
| CLAUDE_CODE_PLUGIN_PREFER_HTTPS | v2.1.141 | Clone GitHub plugin sources over HTTPS instead of SSH for environments without a GitHub SSH key |
Claude Code received substantial performance and rendering engine work in March and April 2026, focused on cutting startup time, eliminating visual flicker, and reducing memory pressure during long sessions.
Introduced in v2.1.89-90 in April 2026, the NO_FLICKER rendering engine replaces the previous redraw model with alt-screen buffering. The terminal renders to an off-screen buffer and only swaps regions that have actually changed, eliminating the flicker that had been visible during streaming responses, status-line updates, and tool-call panels. The engine is paired with a TypeScript rewrite of the scrolling subsystem (v2.1.85) that replaced an earlier WebAssembly implementation.[55]
Focus View, also introduced in v2.1.90, is a toggle activated via Ctrl+O that hides ancillary UI panels and presents only the active conversation, intended for screen recording, pair programming, and distraction-light coding sessions. It was further refined in v2.1.97.[55]
In v2.1.113 (April 17, 2026), Claude Code migrated from a bundled JavaScript runtime to a native CLI binary. The change cut cold-start latency and lowered the resident memory footprint, particularly on systems where Node.js startup overhead had been the largest contributor to perceived slowness.[55]
| Area | Change | Approximate Improvement |
|---|---|---|
| /resume on large sessions | Rewritten command path (v2.1.116) | 67% faster |
| Branch-heavy sessions | Optimization pass (v2.1.77) | 45% faster |
| Write tool diff calculation | Reworked algorithm | 60% faster |
| Startup memory | Multiple passes (v2.1.80 and later) | 18 to 80MB reduction |
| SSE event handling | Algorithm complexity fix | O(n^2) reduced to O(n) |
| Prompt rendering cycles | Render-pipeline optimization | About 74% reduction |
| macOS startup | Cold-start tuning | About 60ms savings |
| MCP server connection | Concurrent startup (v2.1.117) | Subsecond initialization |
These changes accumulated across roughly 30 patch releases between v2.1.69 and v2.1.117 in five weeks of intensive iteration.[52][55]
Ultraplan, introduced in v2.1.91 in April 2026 as an early preview, hands a planning task from the local CLI to a Claude Code on the web session running in plan mode. While the cloud session drafts the plan, the developer keeps working in their terminal. When the draft is ready, a browser-based review interface offers inline comments on specific sections, emoji reactions to signal approval or concern, and an outline sidebar for navigating longer plans.[54]
Once the plan is approved, the developer can inject it into the current local conversation and continue, start a new session against the plan, or save the plan to a file without executing it. Ultraplan sessions run Claude Opus 4.6 (and later Opus 4.7) inside Anthropic's Cloud Container Runtime for up to 30 minutes per session, while the local terminal polls every 3 seconds for updates.[54]
| Requirement | Detail |
|---|---|
| Claude Code version | v2.1.91 or later |
| Account | Claude Code on the web account |
| Repository | A GitHub repository linked to Claude Code |
| Runtime | Anthropic's default cloud environment for the account |
| Mode | Research preview (behavior may change) |
The first invocation of /ultraplan auto-creates a cloud environment for the account if one does not already exist.[55]
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:
# Prerequisite: Node.js 18+
npm install -g @anthropic-ai/claude-code
# Start in your project directory
cd your-awesome-project
claude
# For macOS, Linux, WSL - Stable version
curl -fsSL https://claude.ai/install.sh | bash
# Latest version
curl -fsSL https://claude.ai/install.sh | bash -s latest
# Specific version (example: 1.0.128)
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>
### Update Control Environment Variables
Two environment variables control how Claude Code receives updates:
| Variable | Effect |
| --- | --- |
| `DISABLE_AUTOUPDATER` | Disables background auto-updates while still allowing manual `claude update` |
| `DISABLE_UPDATES` | Blocks all update paths, including manual `claude update` (added April 2026, stricter than `DISABLE_AUTOUPDATER`)<sup><a href="#cite_note-55" class="cite-ref">[55]</a></sup> |
These variables are intended for tightly controlled enterprise environments where Claude Code versions are managed by configuration management or vendored into the build pipeline.
### 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) |
| **/usage** | Unified usage and stats view (merged from /cost and /stats, April 2026) |
| **/theme** | Create and switch between named custom themes (April 2026) |
| **/ultraplan** | Hand off planning to a cloud Claude Code session in plan mode (v2.1.91+, April 2026) |
| **/resume** | Resume previous sessions; rewritten and 67% faster on large sessions (v2.1.116, April 2026) |
| **/powerup** | Interactive learning system for Claude Code features (v2.1.89-90, April 2026) |
| **/team-onboarding** | Auto-generate a team quick-start guide for the current repository (v2.1.101, April 2026) |
| **/release-notes** | Interactive version selector for browsing changelogs (v2.1.92, April 2026) |
| **/copy w** | Write selected content directly to a file (v2.1.72, April 2026) |
| **/plan** | Plan mode entry; supports a description parameter (v2.1.72, April 2026) |
| **/claude-api** | Built-in skill for Claude API and Anthropic SDK development (v2.1.69, April 2026) |
| **/goal** | Define an outcome-based completion condition for autonomous multi-turn execution (v2.1.139, May 2026) |
| **/fast** | Toggle Fast Mode on or off for the current session (May 2026) |
| **/bg** | Send the current session to the background and return to Agent View (v2.1.139, May 2026) |
| **/feedback** | Submit feedback to Anthropic; can attach recent session transcripts (v2.1.141, May 2026) |
### Vim Modes
Beyond enabling Vim keybindings via /vim, Claude Code added visual mode (v) and visual-line mode (V) in April 2026. Visual modes support selections, operators applied to selections, and on-screen highlighting of the current selection. The implementation matches the most commonly used subset of Vim's visual semantics, intended for developers who use Vim as a daily driver and prefer modal text manipulation in the prompt area.<sup><a href="#cite_note-55" class="cite-ref">[55]</a></sup>
### Usage and Stats
The /cost and /stats commands were merged into a single /usage view in April 2026, with both names retained as typing shortcuts that open the relevant tab inside the unified panel. The view shows current spend, remaining limits within the 5-hour and weekly windows, model selection, and a session-by-session breakdown.<sup><a href="#cite_note-55" class="cite-ref">[55]</a></sup>
### 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>
```bash
# 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
On September 29, 2025, Anthropic renamed the Claude Code SDK to the Claude Agent SDK, reflecting its broader capabilities beyond coding.[16] The SDK provides developers with the same infrastructure that powers Claude Code, including:
| 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 |
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.[16]
Claude Code is available through multiple subscription tiers and deployment options:[25]
| 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, Opus 4.7, and Opus 4.8) | 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.[8] Opus 4.8 kept the same regular pricing as Opus 4.7 at $5 per million input tokens and $25 per million output tokens; its Fast Mode runs roughly 2.5x faster while costing about three times less than the previous generation of Fast Mode, at $10 per million input tokens and $50 per million output tokens.[57]
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.[25]
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), and cloud-delegated (OpenAI Codex). The headline difference is interface and autonomy: Claude Code is terminal-native and agentic by default (no inline autocomplete), Cursor is a custom VS Code fork, Copilot is an IDE plugin best known for inline suggestions, and Codex runs in cloud sandboxes.[27]
| Feature | Claude Code | Cursor | GitHub Copilot | 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.8 / Opus 4.7 / 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) |
| 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.[27]
The VS Code extension, which reached general availability on September 29, 2025, provides the most polished IDE integration for Claude Code. Key features include:[3][13]
The extension is available through the VS Code Marketplace and is compatible with VS Code, Cursor, and Windsurf editors.
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.[28]
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.
Claude Code offers an official GitHub Action (anthropics/claude-code-action) that brings agentic capabilities directly into CI/CD pipelines. The action can:[14]
@claude mentions in pull request comments and issue discussionsThe action supports multiple authentication methods including direct Anthropic API, Amazon Bedrock, Google Cloud Vertex AI, and Microsoft Foundry. It is built on top of the Claude Agent SDK.[14]
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[10] |
| SWE-bench Verified | Claude Sonnet 4.5 | 77.2% | Average of 10 trials; 82.0% with high-compute setup[4] |
| SWE-bench Verified | Claude Opus 4 | 72.5% | State-of-the-art as of May 2025[2] |
| SWE-bench Verified | Claude Sonnet 4 | 72.7% | As of May 2025[2] |
| OSWorld | Claude Sonnet 4.5 | 61.4% | Real-world computer task benchmark[4][8] |
| Terminal-bench | Claude Opus 4 | 43.2% | Terminal automation benchmark[2] |
| Sustained Performance | Claude Sonnet 4.5 | 30+ hours | Autonomous coding, building 11K-line apps[4] |
| Sustained Performance | Claude Opus 4 | 7 hours | Autonomous refactor validated by Rakuten[2] |
| Internal Code Editing | Claude Sonnet 4.5 | 0% error rate | Reduced from 9% on Sonnet 4[4] |
| Code Review Accuracy | Claude Opus 4.6 | <1% incorrect | Less than 1% of review findings marked incorrect by engineers[46] |
| CursorBench | Claude Opus 4.7 | 70% | Versus 58% for Opus 4.6 (April 2026)[51] |
| Agentic Coding (SWE-bench Pro) | Claude Opus 4.7 | 64.3% | Hardest SWE-bench variant; real maintained repos[51][57] |
| Agentic Coding (SWE-bench Pro) | Claude Opus 4.8 | 69.2% | New record for publicly available models (May 2026)[57] |
| Security Scanning | Claude Opus 4.6 | 500+ vulns found | In production open-source codebases undetected for decades[47] |
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[2][4]
Replit: Reported "dramatic advancements for complex changes across multiple files"[2]
GitHub: Introduced Claude Sonnet 4.5 as the model powering GitHub Copilot coding agent[29]
Sourcegraph: Described it as "substantial leap in software development"[2]
Augment Code: Higher success rates in complex tasks for Sonnet 4.5[4]
iGent: Excellence in autonomous app development[4]
Manus: Improved instruction following and outputs[4]
Block: Boosts code quality in agents[4]
Cognition: Handles complex challenges better[4]
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.[6][12]
| 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 |
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.[6][12]
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, and others.[12] On May 28, 2026, Anthropic announced a $65 billion Series H at a $965 billion post-money valuation, led by Altimeter Capital, Dragoneer, Greenoaks, and Sequoia Capital, roughly tripling the Series G valuation and pushing the company past OpenAI as the most valuable AI startup. Anthropic said its run-rate revenue had crossed $47 billion earlier that month, up from $14 billion in February, growth it attributed in part to Claude Code and enterprise adoption.[60]
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.[7]
| Date | Version/Release | Description |
|---|---|---|
| March 2023 | Initial Claude | First Claude model released[2] |
| February 24, 2025 | Claude 3.7 Sonnet | Released with Claude Code beta research preview[1] |
| April 18, 2025 | Best Practices | Published Claude Code best practices guide[26] |
| May 22, 2025 | Claude 4 GA | Claude Opus 4 and Sonnet 4 released; Claude Code announced as Generally Available[2] |
| May 23, 2025 | Cloud Integration | Extended availability to AWS Bedrock and Google Vertex AI[8] |
| June 2025 | IDE Extensions | VS Code and JetBrains beta extensions released[2] |
| June 26, 2025 | Desktop Extensions | One-click MCP server installation for browsers[30] |
| June 30, 2025 | Hooks Support | Claude Code hooks support added[19] |
| July 4, 2025 | Subagents | Custom subagents feature released[21] |
| August 2025 | Rate Limits | New weekly rate limits introduced for Pro and Max plans[31] |
| September 29, 2025 | Claude Code 2.0 | Checkpoints, VS Code extension (GA), terminal v2.0, Claude Agent SDK released[3] |
| September 29, 2025 | Claude Sonnet 4.5 | New default model with 30+ hour autonomous operation capability[4] |
| October 20, 2025 | Claude Code on Web | Web-based version launched at claude.ai/code for Pro and Max subscribers[23] |
| Early 2026 | Claude Code 2.1.0 | Hooks for agents/skills, hot reload, session teleportation, language output[5] |
| February 5, 2026 | Agent Teams | Multi-agent coordination feature released as research preview (v2.1.32)[17] |
| February 10, 2026 | Claude Opus 4.6 | 1M context, 128K output tokens; becomes default model for Claude Code[10] |
| February 20, 2026 | Claude Code Security | Vulnerability scanning and patch suggestions (limited research preview)[47] |
| March 9, 2026 | Code Review | Multi-agent automated PR review for Team and Enterprise (research preview)[41] |
| March 13, 2026 | v2.1.75 | 1M context window default for Opus 4.6 on Max/Team/Enterprise[44] |
| March 14, 2026 | v2.1.76 | MCP elicitation, /effort command, PostCompact hook, session quality survey[44] |
| March 17, 2026 | v2.1.77-v2.1.78 | Opus 4.6 output limit raised to 64K/128K, line-by-line streaming, StopFailure hook[44] |
| March 19, 2026 | v2.1.79-v2.1.80 | Channels (research preview), /voice improvements, /remote-control for VS Code[44] |
| March 20, 2026 | v2.1.81 | --bare flag, --channels permission relay, voice mode fixes[44] |
| March 23, 2026 | Computer Use | Claude Code gains macOS computer use capability (research preview)[45] |
| April 16, 2026 | Claude Opus 4.7 | New default model for Claude Code; xhigh effort default for Opus 4.7[51] |
| April 17, 2026 | v2.1.113 | Native CLI binary, /loop Remote Control, Windows Ctrl+Backspace fix[55] |
| April 17-22, 2026 | v2.1.114-v2.1.117 | Permission dialog crash fix, /resume rewrite, concurrent MCP startup, persistent /model[55] |
| April 2026 | Vim visual modes, /usage, themes | v and V visual modes; merged /cost and /stats; named themes via /theme[55] |
| April 2026 | /ultraplan early preview | Cloud planning sessions with browser review interface (v2.1.91)[54] |
| April 2026 | NO_FLICKER, Focus View, /powerup, /team-onboarding | Major rendering and onboarding additions across v2.1.85 to v2.1.101[52][55] |
| April 23, 2026 | Quality postmortem | Anthropic disclosed three bugs and reset usage limits for all subscribers[53] |
| May 12, 2026 | v2.1.139, Agent View, /goal | Multi-session dashboard via claude agents; outcome-based autonomous execution; /bg background command[56] |
| May 13, 2026 | v2.1.141 | terminalSequence hook field; ANTHROPIC_WORKSPACE_ID; Rewind "summarize to here"; auto-mode permission dialog detail[56] |
| May 14, 2026 | Fast Mode GA on Opus 4.7 | /fast toggle delivers roughly 2.5x faster Opus responses; Opus 4.7 becomes the default fast-mode model[56] |
| May 15, 2026 | v2.1.143 | Plugin dependency enforcement; plugin cost preview; worktree.bgIsolation; PowerShell ExecutionPolicy Bypass[56] |
| May 28, 2026 | Claude Opus 4.8, v2.1.154 | New default model; dynamic workflows research preview; announced with Series H funding[57][59][60] |
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[3][13]
JetBrains: Beta extension with inline edit display, integrated via AI chat and JetBrains AI subscription[28]
Installation is available through running Claude Code in the IDE terminal or via extension marketplaces.[3]
| 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[14] |
| Amazon Bedrock | API Provider | Enterprise deployment |
| Google Vertex AI | API Provider | Enterprise deployment |
| Microsoft Foundry | API Provider | Enterprise deployment |
| GitHub Copilot | Model Integration | Claude Sonnet 4.5 available in Copilot[29] |
| Telegram | Channels (research preview) | Two-way messaging, permission relay[42] |
| Discord | Channels (research preview) | Two-way messaging, permission relay[42] |
Claude Code uses a special CLAUDE.md file for persistent context and project documentation. This file can contain:[26]
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
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.[26][33]
Starting in April 2026, Claude Code supports named custom themes. Themes can be created and switched via the /theme command or hand-edited as JSON files in ~/.claude/themes/. Plugins can also ship themes via a themes/ subdirectory, allowing community-distributed color schemes that follow the same accessibility-aware palette structure as the built-in light and dark themes.[55]
The /statusline command opens an editor for customizing the persistent status line shown beneath the prompt. The status line can include the active model, the current Git branch, token usage, the working directory, and arbitrary shell-evaluated fields. Users can pipe shell command output into the status line to display CI status, deployment information, or any other contextual signal.[26]
Recommended workflow patterns include:[26]
Read relevant files and context first without writing code
Use subagents for complex problems to preserve context
Create a plan before implementing changes
Use checkpoints before major edits
Clear context between unrelated tasks
Monitor usage with /status command
As of early 2026, Claude Code has several documented limitations:[8]
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 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.[24]
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.)[34][35]
These consumer policies do not apply to commercial/government/education contracts or API use via providers like Amazon Bedrock and Vertex AI[34]
User feedback is used for improvements but not for generative model training[8]
Feedback transcripts are stored for only 30 days[8]
Limited retention periods with restricted access to session data[8]
Optional telemetry can be disabled; environment variables allow opt-out[36]
Local-first approach with no cloud storage of code[37]
Code Review is not available for organizations with Zero Data Retention enabled[41]
On April 23, 2026, Anthropic published an engineering postmortem addressing user reports of degraded Claude Code quality between early March and mid-April 2026. The post identified three independent bugs that had compounded to produce the observed regressions, and Anthropic reset usage limits for all Claude Code subscribers as a remediation.[53]
| Date | Bug | Effect |
|---|---|---|
| March 4, 2026 | Default reasoning effort lowered from high to medium to address UI freezing during extended thinking | Users experienced a perceived intelligence drop because they preferred higher accuracy over faster responses |
| March 26, 2026 | A prompt-cache optimization meant to clear stale thinking from idle sessions cleared thinking history on every turn instead of once | Sessions appeared forgetful and repetitive while burning through usage limits faster than expected |
| April 16, 2026 | A new system-prompt instruction limiting between-tool text to 25 words combined with other changes to reduce coding quality by about 3% | Coding output quality measurably regressed on internal benchmarks |
All three issues were fixed by April 20, 2026 (v2.1.116). The default reasoning effort was raised back to high (and later xhigh for Opus 4.7), the caching bug was reverted, and the verbosity instruction was tuned. Anthropic also announced several preventative measures: broader internal testing on public builds, improved code-review tooling with multi-repository context, stricter controls on system-prompt changes that affect intelligence, and gradual rollouts for any change that could affect output quality.[53][51]
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.[7]
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.[7]
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.[38]
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.[41][47]
Community resources have emerged around Claude Code, including the awesome-claude-code repository for slash-commands and guides.[39] A Claude Code CLI Cheatsheet has been published to help developers maximize their usage.[40]
On May 28, 2026, Anthropic released Claude Opus 4.8, which became the new default model for Claude Code on paid plans through version v2.1.154, superseding Claude Opus 4.7. Anthropic described the model as having sharper judgment, more honesty about its own progress, and the ability to work independently for longer than its predecessors. The most emphasized improvement was reliability about its own work: in Anthropic's internal testing, Opus 4.8 failed to flag flaws in its own code in 3.7% of cases, down from 19.7% for Opus 4.7, making it roughly four times less likely to let a defect pass unflagged. Anthropic states that "Opus 4.8 is around four times less likely than its predecessor to allow flaws in code it has written to pass unremarked," and that "early testers report that Opus 4.8 is more likely to flag uncertainties about its work and less likely to make unsupported claims." Opus 4.8 defaults to high effort in Claude Code, with /effort xhigh recommended for the hardest tasks.[57][58]
Opus 4.8 kept the same regular pricing as Opus 4.7 at $5 per million input tokens and $25 per million output tokens. Fast Mode on Opus 4.8 runs roughly 2.5x faster while costing about three times less than the previous generation of Fast Mode, at $10 per million input tokens and $50 per million output tokens.[57][58]
| Capability | Opus 4.7 | Opus 4.8 |
|---|---|---|
| Agentic coding | 64.3% | 69.2% |
| Multidisciplinary reasoning with tools | 54.7% | 57.9% |
| Agentic computer use | 82.8% | 83.4% |
| Agentic financial analysis | 51.5% | 53.9% |
| Knowledge work (index) | 1753 | 1890 |
| Failure to flag own code errors | 19.7% | 3.7% |
Alongside Opus 4.8, Claude Code v2.1.154 introduced dynamic workflows as a research preview. A developer asks Claude to create a workflow, and Claude orchestrates work across tens to hundreds of parallel subagents running in the background, aimed at large tasks such as codebase-scale migrations spanning hundreds of thousands of lines of code. The /workflows command lists active and past runs. The trigger keyword started as workflow and was later renamed to ultracode, rendered in violet, in v2.1.160.[57][59]
Anthropic announced the model and the workflow feature on the same day it disclosed its Series H funding round. The company raised $65 billion at a $965 billion post-money valuation, led by Altimeter Capital, Dragoneer, Greenoaks, and Sequoia Capital, with $15 billion of previously committed hyperscaler investment including $5 billion from Amazon. The round roughly tripled the $380 billion valuation from the February 2026 Series G and pushed Anthropic past OpenAI as the most valuable AI startup. Anthropic said its run-rate revenue had crossed $47 billion earlier that month, up from $14 billion in February, growth that the company attributed in part to Claude Code and enterprise adoption.[60]
Claude Code also shipped a series of point releases between v2.1.144 (May 19) and early June 2026 that expanded review, skill, and plugin tooling. The /code-review --fix option (v2.1.152) applies a review's findings directly to the working tree after the review completes, and the same release added a /reload-skills command to re-scan skill directories without restarting, a disallowed-tools frontmatter field that lets a skill or slash command strip tools from the model, and a MessageDisplay hook event that can transform or hide assistant message text before it is shown. The /usage view gained a per-category breakdown across skills, subagents, plugins, and MCP servers (v2.1.149), and Markdown rendering began honoring GitHub-flavored task list checkboxes. Background sessions gained a non-interactive entry point through claude --bg --exec '<command>' (v2.1.154). Auto mode reached the Amazon Bedrock, Google Cloud Vertex AI, and Microsoft Foundry providers for Opus 4.7 and Opus 4.8 (v2.1.158), and a claude plugin init scaffolding command plus mid-session switching between Claude-managed worktrees via EnterWorktree arrived in v2.1.157.[59]