Claude Code: The Complete 2026 Developer Guide

Claude Code is the agentic coding tool that, in April 2026, posts the highest SWE-bench Verified score of any model shipping inside a mainstream coding agent: 80.8% with Sonnet 4.6. It uses roughly 5.5 times fewer tokens than Cursor on identical tasks, runs in your terminal, VS Code, JetBrains, Desktop app, or browser, and shares a single configuration layer across all of them. If you write code for a living in 2026, this is the tool to understand.

This guide is a hub, not a quickstart. The official Anthropic documentation is excellent — we will not paraphrase it. Instead, we orient you by profile, surface the five concepts that actually matter, call out the mistakes everyone makes, and link to the deep dives in our cluster for each topic. Read the section that matches your situation, follow the links that matter to you, and skip the rest.

Claude Code in 30 seconds

Claude Code is an agent, not an autocomplete. When you type `claude "write tests for the auth module, run them, and fix any failures"`, it reads your codebase, plans the changes across multiple files, executes commands, iterates on failures, and returns results. That is different from GitHub Copilot (which predicts the next token) and different from Cursor's chat (which generates code you then paste). Claude Code operates closer to a human engineer than a keyboard accelerator.

It runs on any of five surfaces that share the same engine: terminal CLI, VS Code extension, JetBrains plugin, Desktop app (macOS/Windows), and web at claude.ai/code. Your `CLAUDE.md` files, settings, skills, and MCP servers work across all of them — start in one, continue in another.

It runs on Anthropic's models by default (Opus 4.7 with 1M context, Sonnet 4.6, Haiku 4.5), with support for AWS Bedrock, Microsoft Foundry, and Google Vertex AI for teams that need a specific cloud.

Install in under a minute

On macOS or Linux, a single command installs the CLI and sets it up to auto-update in the background. On Windows you have three choices: PowerShell, CMD, or WinGet — all documented below.

                      
                        # macOS, Linux, WSL
curl -fsSL https://claude.ai/install.sh | bash

# Homebrew (stable channel, no auto-update)
brew install --cask claude-code

# Windows PowerShell
irm https://claude.ai/install.ps1 | iex

# Windows WinGet
winget install Anthropic.ClaudeCode

# Then start a session in any project
cd your-project
claude
                      
                    

For VS Code, install the `anthropic.claude-code` extension from the Marketplace — it gives you inline diffs, @-mentions of files, plan review inside the editor, and full conversation history without leaving the IDE. JetBrains users get a native plugin with interactive diff viewing for IntelliJ, PyCharm, WebStorm, and siblings.

Which plan should you pay for?

There is no free tier for Claude Code — you need a Claude subscription. The honest answer for most developers is Pro at $17/month (annual) or $20/month (monthly). It unlocks Claude Code, gives you access to all three models (Opus 4.7, Sonnet 4.6, Haiku 4.5), and works well for 5-10 hours of daily use.

Upgrade to Max at $100/month only if you hit the Pro rate limits regularly. Max offers 5x or 20x the Pro usage budget and is priced for heavy agentic workflows — people running `/batch` migrations, running routines on the cloud, or keeping multiple parallel sessions hot all day. A useful heuristic: if you find yourself running `/usage` and seeing near-zero remaining quota more than once a week, Max pays for itself.

The benchmark that matters for ROI: Claude Code consumes 5.5x fewer tokens than Cursor on identical tasks (188K tokens vs 33K on the same benchmark task). At $20/month you get meaningfully more useful work out of Claude Code than out of Cursor for the same price. Full numbers and methodology are in our Claude Code review.

Pick your profile

Claude Code's feature surface is large. The fastest way to make it yours is to read the profile that describes you and skip the rest.

Profile 1: Solo developer shipping fast

You want to ship features, not configure tools. Your setup takes twenty minutes, not an afternoon.

• Install the CLI, run `claude` in your project, let it introduce itself.
• Run `/init` in your project root. Claude analyzes your codebase and writes a starter `CLAUDE.md` with your build commands, test instructions, and conventions. Edit it down to under 200 lines — lean CLAUDE.md files drive better adherence than long ones.
• Add two or three skills for things you do more than once a day. Good starting candidates: a `/commit` skill that runs tests then writes a conventional commit message, a `/review` skill that checks your own code before PR. See our guide on skills for the full pattern.
• Bookmark three commands: `/plan` (enter plan mode before a complex change), `/context` (see where your token budget is going), `/compact` (free context mid-session without losing CLAUDE.md).

The stack that produces the most output in 2026 is Claude Code plus Cursor — Claude Code for multi-file changes, refactors, and agentic work; Cursor for inline edits and the visual file tree. They cost $40/month combined and they do not compete with each other. Your CLAUDE.md is the single file that makes both of them smarter about your project.

Profile 2: Team adopting Claude Code

You need every teammate to get the same behavior, without asking each of them to configure Claude Code the same way. The leverage lives in three shared assets.

• Commit a project `CLAUDE.md` at your repo root (or `.claude/CLAUDE.md`). This is shared via git. Put in it: build and test commands, architecture diagram, naming conventions, the rules code review catches most often. Keep it under 200 lines. See our CLAUDE.md anatomy guide for a working example.
• Split specialized rules into `.claude/rules/` with `paths:` frontmatter. A `rules/api-design.md` scoped to `src/api/**/*.ts` only loads into context when Claude is actually working on an API file. This keeps the main CLAUDE.md lean while giving depth where it matters.
• Deploy managed settings for organization-wide guardrails. Use `permissions.deny` to block dangerous tools, `env` for provider routing, and `forceLoginOrgUUID` to pin the account. Technical enforcement belongs in settings; behavioral guidance belongs in CLAUDE.md.
• Add project skills under `.claude/skills/`. Every teammate gets `/deploy`, `/review-pr`, `/fix-issue ` for free. Onboarding goes from 'read these 40 pages of internal docs' to 'type `/powerup` and follow the lessons.'
• Write a few hooks. A `PreToolUse` hook on `Bash(rm *)` with `exit 2` blocks destructive commands; a `PostToolUse` hook on `Edit|Write` can auto-format your language's files. Hooks are deterministic enforcement — CLAUDE.md is just context.

Profile 3: Power user going agentic

You understand the basics and you want to squeeze every token, every second, and every edge case out of Claude Code.

• Use `/batch` for anything larger than a single file refactor. `/batch migrate src/ from Solid to React` decomposes the work into 5-30 independent units, spawns a background agent for each in its own git worktree, runs tests, and opens a pull request per unit. It is the single biggest productivity multiplier shipped in 2026. Full walkthrough in our skills deep dive.
• Write skills that fork into subagents with `context: fork`. A research skill drops into the `Explore` agent with read-only tools and returns a summary — your main conversation never sees the raw logs and file contents. Less context pollution, faster answers.
• Inject live data into skills with the `` !`shell command` `` syntax. Your skill runs `!`gh pr diff`` before Claude sees it, so Claude starts with the actual diff, not a request to go fetch it.
• Use `isolation: worktree` on subagents that modify code. The subagent gets an isolated copy of your repo. If it makes no changes, the worktree auto-cleans. Perfect for exploratory refactors you might not keep.
• Pin MCP servers to specific subagents. Inline `mcpServers:` frontmatter in a subagent gives it Playwright or Sentry tools without adding those tool descriptions to your main conversation's context window.
• Enable persistent memory with `memory: user` on your favorite subagents. A `code-reviewer` subagent that accumulates patterns across months of use beats a stateless one every time.

The five concepts that actually matter

Most of Claude Code's surface area reduces to five primitives. Understand these and the rest is detail.

1. `CLAUDE.md` is the system prompt for your project. Plain markdown, checked into git, read at session start. Keep it specific, keep it under 200 lines, keep it honest. For the full anatomy including imports, scopes, and path-scoped rules, see The anatomy of a great CLAUDE.md file.

2. Skills are reusable playbooks. A `SKILL.md` file in `.claude/skills//` (project) or `~/.claude/skills//` (personal) becomes `/name` — Claude can invoke it automatically when relevant, or you can type it. Unlike CLAUDE.md content, a skill's body loads only when invoked, so you can write long reference material without paying for it in context. Full guide: Claude Code Skills.

3. Hooks are shell commands that fire on specific Claude Code events (PreToolUse, PostToolUse, SessionStart, Stop, and about a dozen others). They are deterministic — unlike CLAUDE.md which is context, hooks enforce. Use them to block `rm -rf`, auto-format on save, run tests before commit, or send a Slack message when a long task finishes.

4. MCP servers (Model Context Protocol) are the standard way Claude Code talks to external tools and data. One command — `claude mcp add --transport http github https://api.githubcopilot.com/mcp/` — and Claude can review your GitHub PRs. Same pattern for Sentry, Notion, Stripe, PostgreSQL, Playwright, and hundreds of others listed at the official MCP registry.

5. Subagents are specialized assistants that run in their own context window with their own tools. Built-in agents include `Explore` (read-only, Haiku-powered, optimized for search) and `Plan` (read-only, used during plan mode). You can write custom subagents with `.claude/agents/.md`, give them persistent memory with `memory: user`, restrict their tools with `disallowedTools`, or isolate them in a git worktree.

The mistakes everyone makes

We have spent serious time with Claude Code. These are the failure modes we see in almost every project when someone is getting started.

• A 2,000-line CLAUDE.md. Past 200 lines, Claude's adherence drops. Split into `@imports` or `.claude/rules/` with `paths:` frontmatter. Lean files drive better behavior than comprehensive ones.
• Hooks using `exit 1` instead of `exit 2`. Exit code 1 is non-blocking — your hook runs but does not stop the action. Only `exit 2` blocks. Many users discover this only after a dangerous command runs anyway.
• Skills that never trigger. If Claude does not invoke your skill when you expect it to, the description is too vague. Skills are matched against user intent by keywords in the description and `when_to_use` fields. Front-load the key use case — the first 1,536 characters of combined text are what Claude sees in the skill listing.
• Exploding the token budget on agentic workflows. `/batch` and long plan mode sessions burn tokens fast. Monitor with `/context` and `/cost`. If you hit the Pro rate limit more than once a week, upgrade to Max — your time is worth more than $80/month.
• Using CLAUDE.md for procedures. If a section of your CLAUDE.md describes multi-step instructions ('When deploying: first run tests, then build, then push to staging…'), migrate it to a skill. Procedures belong in skills, which load only when invoked. Facts and conventions stay in CLAUDE.md.
• Trusting CLAUDE.md as enforcement. It is context, not a guarantee. If a rule is critical (no writes to `/etc`, no commits without tests), enforce it with hooks or managed `permissions.deny`.

What to read next

This hub is a map, not a manual. The depth lives in the cluster:

• Claude Code Skills: the 2026 guide — The six bundled skills you should know (including `/batch`), how to write your own, how `context: fork` turns a skill into a subagent, and a ready-to-install skill you can copy into `~/.claude/skills/` today.
• The anatomy of a great CLAUDE.md file — The five rules, a real CLAUDE.md dissected line by line, when to split with `.claude/rules/`, and a bonus linter skill that audits your file for contradictions and token bloat.
• Claude Code review — The benchmarks (5.5x token efficiency vs Cursor, 80.8% SWE-bench Verified, 67% blind-test win rate), honest pros and cons, pricing breakdown, and our verdict.
• Official Anthropic documentation — For reference. Excellent, exhaustive, updated continuously.
• awesome-claude-code — Community-curated list of skills, hooks, slash commands, and plugins.

FAQ

Claude Code versus Cursor — which should I use? Different philosophies. Cursor is an IDE-first tool that assists you with completions and chat; you stay in the driver's seat. Claude Code is agentic — you describe the outcome, it plans and executes across multiple files. The developers who ship the most in 2026 use both ($40/month combined): Cursor for daily editing, Claude Code for multi-file tasks, refactors, and anything agentic. On identical benchmark tasks, Claude Code uses 5.5x fewer tokens and wins 67% of blind-test code quality comparisons.

Is Claude Code free? No. It is included in Claude Pro ($17/month annual, $20/month monthly) and Claude Max ($100/month and up). There is no free tier. The Anthropic free plan gives you chat access to Claude but not Claude Code.

Does Claude Code work with my IDE? VS Code (via marketplace extension), JetBrains IDEs (IntelliJ, PyCharm, WebStorm, and others), terminal, Desktop app for macOS and Windows, and web at claude.ai/code. Your CLAUDE.md and settings follow you across all of them.

How much will it actually cost me per month? For the majority of developers, Pro ($20/month) is enough. If you run `/batch` migrations, use `/ultrareview` frequently, or chain long agentic sessions, move to Max ($100/month) — you will hit Pro's rate limits otherwise. Enterprise teams typically use the per-seat plans.

Where do I start if I am brand new? Install the CLI, run `claude` in an existing project, type `/init`, and edit the generated `CLAUDE.md` down to the essentials. That gets you 80% of the value in under 30 minutes. Then pick one skill to write for something you do more than once a day. The rest of this cluster will make more sense once you have a few real sessions under your belt.

Is it safe to use on production codebases? Claude Code asks for permission on every file write, shell command, and external tool call by default. You can tighten this further with `permissions.deny` rules, `disallowedTools` on subagents, or managed settings deployed by IT. Hooks let you enforce project-specific safety rules deterministically. For regulated environments, Microsoft Foundry and Google Vertex AI providers support HIPAA and FedRAMP deployments.