Friday, 10 p.m. You open your terminal, type claude, paste in the Linear ticket "fix the Stripe double-billing bug", and go make yourself a coffee. By the time you're back, the bug has been found and fixed across three files, the tests pass, the commit is ready, and the PR is open with a clear description. You approve it. That's Claude Code in 2026: a coding agent that lives in your terminal, reads your entire codebase, and writes, tests, commits and opens PRs on your behalf. Think of it less as an editor plugin or a souped-up autocomplete and more as a colleague who makes decisions, working inside the console you already have open. Anthropic ships it with its Claude Sonnet 4.6 and Opus 4.7 models and includes it in the Pro plan at $17/month. The rest of this article gets practical: what it does, how to install it, how to configure it so it becomes genuinely useful, and where it beats (or doesn't beat) Cursor, GitHub Copilot and Codex.
What exactly is Claude Code?
Claude Code is an agentic coding tool built by Anthropic. "Agentic" means two specific things. First, it makes decisions without needing its hand held. Second, it acts: it reads files, runs shell commands, launches tests, edits code and makes Git commits. It goes well beyond making suggestions.
The official docs describe it as "an agentic coding tool that reads your codebase, edits files, runs commands, and integrates with your development tools." It's available in the terminal, VS Code, JetBrains, the desktop app, the web (claude.ai/code) and even on iOS through the Claude app.
How it differs from Claude.ai (the web version)
Claude.ai is the chat in your browser. You paste code in, talk it through, and copy bits of the answer back out. Everything goes through copy-paste. It's handy for brainstorming, but the context dies with the session and the tool never touches your project.
Claude Code works the other way around. You hand it a folder. It reads the file tree, understands the dependencies, and opens whichever files it judges relevant. It keeps your CLAUDE.md in mind, along with your history and your conventions. It edits in place. It commits. It's the difference between a consultant you call on the phone and a senior developer you've hired full time.
If you want to place Claude Code within the new generation of tools where you code with AI rather than alongside it, the conceptual framework is vibe coding: you describe the intent, and the agent executes.
To give it a persistent server with files, automations and hosted services, our Zo Computer review covers that execution layer in detail.
Claude Code's day-to-day tasks
The most common use cases:
- Reading an unfamiliar repo and explaining its architecture in 30 seconds
- Writing missing tests for an untested module, running them, and fixing the failures
- Refactoring a function across ten files in one go
- Reproducing a bug from an error message, finding the root cause, and proposing a fix
- Creating a clean commit with a descriptive message and opening the PR
- Updating dependencies and resolving merge conflicts
- Translating a set of strings into ten languages via a CI script
You stay in your terminal. You approve or reject.
Install Claude Code and get started in 3 minutes
Installation takes about as long as a coffee. Anthropic recommends the native install, which creates a standalone binary that updates itself.
# macOS, Linux, WSL
curl -fsSL https://claude.ai/install.sh | bash
# Windows PowerShell
irm https://claude.ai/install.ps1 | iex
# Homebrew (macOS)
brew install --cask claude-code
# WinGet (Windows)
winget install Anthropic.ClaudeCode
# npm (legacy but still works)
npm install -g @anthropic-ai/claude-code
On native Windows, Git for Windows is required (WSL2 remains the most stable option). With npm, NEVER use sudo: it creates broken permissions that take more than an hour to untangle.
First launch and authentication
cd path/to/your/project
claude
Claude asks you to authenticate. You have three options: a Claude Pro or Max account (billing shared with claude.ai, recommended for solo devs), Claude Console via OAuth (pay-as-you-go through the API), or Bedrock / Vertex AI / Microsoft Foundry for teams working in locked-down cloud environments.
A free Claude account doesn't give you access to Claude Code. You need at least Pro.
Once it's running, type /help for the list of commands, /resume to pick up your last session, and /permissions to manage authorizations. You're ready to go.
CLAUDE.md: your project's permanent context
Installation tutorials often skip the CLAUDE.md file, even though it has a huge impact on day-to-day quality.
It's a markdown file you put at the root of your project. Claude Code reads it at the start of every session. In it, you write everything you'd explain to a new developer joining the team: the stack, the conventions, the gotchas, the commands that work and the ones that break things. It's plain markdown, structured however you like.
Minimal example for an Astro / TypeScript stack
# CLAUDE.md
## Stack
- Astro 5 + Tailwind 4 + strict TypeScript
- Content in `content/fr/blog/` (markdown with frontmatter)
- Deploy via `npm run build && npm run deploy`
## Conventions
- No `any`: use `unknown` and then narrow
- All components in `.astro` (no React unless already present)
- Slug = kebab-case, never accented characters
## Useful commands
- `npm run lint` before every commit
- `npm run check` for Astro TypeScript checks
- Tests via `vitest run`
## Known gotchas
- Never touch `content/_entry_example.md` (template)
- Images live on media.swanbase.co (CDN), not in the repo
Configuration levels
There are two places to put a CLAUDE.md: at the root of the repo (tracked by Git, shared with the team), and ~/.claude/CLAUDE.md at the user level (your personal preferences, favorite frameworks and style, applied across all your projects).
Since 2026, the official docs add another layer: auto memory. Claude Code learns as it works, saving the build commands that work, the pitfalls it runs into and the implicit conventions it picks up. It enriches your context on its own, between sessions.
The llms.txt format follows the same logic on the AI SEO side: you document the terrain so agents can find their way around. We cover it in how to use llms.txt.
Plan Mode: think before you code
Plan Mode is the feature that separates good usage from industrial-scale accidents. You turn it on by pressing Shift+Tab twice (on Windows, sometimes Alt+M depending on the version).
The idea is simple. Claude switches to read-only. It explores your project, understands the request, and presents you with an implementation plan before making a single change. You read the plan and correct it. Only then does it execute.
Here's why that matters: on a refactor touching fifty files, an agent that charges ahead can neatly break your build and cost you a morning of cleanup. With Plan Mode, the agent lays out its strategy before writing the first line. If the approach is shaky, you catch it there, before the damage is done.
It's also the mode to keep on for sensitive projects: production, finance, healthcare. It's a "look but don't touch" mode until you say "OK, go ahead."
A typical workflow: press Shift+Tab twice, explain the complex task ("add multi-tenant support to every API route"), Claude proposes a structured plan, you critique and amend it, press Shift+Tab to return to normal mode, and Claude executes the approved plan.
Sub-agents, hooks, skills, plugins: the industrialization layer
Out-of-the-box Claude Code is powerful. Configured Claude Code is a different category of tool altogether. The features below take you from solo use to team use.
Sub-agents: delegate to specialists
A sub-agent is a Claude Code inside Claude Code. It runs in its own context window, with its own system prompt and access to a subset of tools. The main agent coordinates, and the sub-agent carries out one specific task.
A typical setup: a code-reviewer agent that can only read and comment on code (never modify it), a test-writer that only writes tests, and a migrator that only touches database migration scripts. You separate responsibilities and limit how much can go wrong.
You create a sub-agent via /agents, then "Create new agent". Storage: .claude/agents/ at the project level, ~/.claude/agents/ at the user level. Format: markdown with YAML frontmatter. You version them in Git, and your teammates get them automatically.
Hooks: event-driven automation
A hook is a shell command that fires automatically at specific points in the Claude Code lifecycle. You don't ask for anything; it just runs.
The key events:
PreToolUse: before a tool call (useful for blocking anything that touches.envorsecrets/)PostToolUse: after a tool call (perfect for runningprettier --writeafter every edit)Notification: when Claude is waiting for your input (to ping Slack or play a sound)
A concrete example: a PostToolUse hook that runs eslint --fix on every modified .ts file. You'll never see a badly formatted PR again. Configure it via /hooks.
Skills: package repeatable workflows
Skills (formerly custom commands) are recipes you write once and share with the whole team: /review-pr, /deploy-staging, /migrate-db. Each one is a mini-prompt with its own tools, rules and steps.
This is where you turn your Notion runbook.md into living automation. A new developer joins, types /onboard, and Claude sets up their environment, configures their keys and walks them through the useful commands.
Plugins: the external catalog
Plugins extend Claude Code with preconfigured skills, sub-agents, hooks and MCP servers. You install them from a marketplace or by referencing them directly in your config.
MCP and Channels: connecting Claude to the rest of your stack
The Model Context Protocol (MCP) is an open standard for connecting AI tools to external data sources. Anthropic published it, and GitHub and OpenAI have adopted it.
An MCP server exposes tools that Claude Code can call: "read Linear ticket #234", "create a GitHub issue", "list the Slack messages where I'm mentioned". You install the MCP server, authorize it, and Claude drives the tool.
The ones that transform a team's workflow: Linear (Claude reads and updates tickets), GitHub (search across PRs, issues and comments), Slack (reading bug threads, posting updates), Google Drive (reading PRDs before building a feature), Notion (syncing internal docs), and your own internal APIs through a fifty-line custom MCP server.
Channels: Telegram, Discord, webhooks
Channels are a layer built on MCP that pushes external events into a running Claude Code session. A bug report lands on Telegram, you forward it to your channel, and the session open on your machine picks up the context with no copy-pasting. The support Discord, the founder's Telegram, the Stripe webhook for failed payments: everything flows into the dev session.
When we assess where Claude Code fits in a 2026 startup stack, we judge it on this integration dimension: an isolated tool is nice, but a tool connected to your whole stack has a multiplier effect. It's the same lens we apply in our review of AI tools for startups in 2026.
Walkthrough: from Linear ticket to merged PR
The typical scenario: a Linear ticket reading "The Stripe webhook stopped processing refunds after the move to API v2".
1. Fetch the ticket via MCP: /mcp linear get-issue ENG-432. Claude reads the summary, the comments and the assignee. No back-and-forth between Linear and the terminal.
2. Switch to Plan Mode (Shift+Tab twice). Give it context: "Read src/webhooks/stripe.ts, identify what changed in v2, and propose a fix plan with tests." Claude spots that the v2 payload uses a new refund_reason field while the handler expects reason. It proposes adding the mapping, writing a test for both the old and new formats, and logging unknown payloads.
3. You approve. Shift+Tab to leave Plan Mode. Claude writes the code and runs the tests: both pass, covering both scenarios.
4. "Commit and open the PR." Claude writes a descriptive message, pushes, opens the PR on GitHub, and the Linear ticket moves to "In Review" automatically via MCP.
The ticket goes into review without you ever leaving the terminal. Doing the same fix by hand means bouncing between Linear, your IDE, GitHub and Slack.
Claude Code vs Cursor, Copilot, Codex in 2026
The question comes up at every demo. All four tools are good, and each one serves a different need.
| Criterion | Claude Code | Cursor | GitHub Copilot | Codex CLI |
|---|---|---|---|---|
| Main surface | Terminal, IDE, Web, Slack | Editor (VS Code fork) | Editor (VS Code, JetBrains extension) | Terminal |
| Agentic mode | Yes, native (sub-agents, plan mode) | Yes (Composer, Agent mode) | Limited (recent Agent mode) | Yes |
| Full codebase awareness | Yes (CLAUDE.md + auto memory) | Yes (indexing) | Limited to open context | Yes |
| MCP support | Native, large catalog | Partial | Not at time of writing | Limited |
| Sub-agents | Yes | No (single agent) | No | No |
| Dedicated Plan Mode | Yes (Shift+Tab) | Not explicit | No | Implicit |
| Automatic shell hooks | Yes | No | No | No |
| Channels (Telegram, Discord) | Yes | No | No | No |
| Models | Sonnet 4.6, Opus 4.7 | GPT-5, Claude, Gemini | GPT family | GPT family |
| Entry price | $17/month (Pro) | $20/month (Pro) | $10/month (Pro) | Included with ChatGPT Plus |
Here's the summary in four lines.
Cursor is still unbeatable if you live in your editor and want "VS Code with a copilot everywhere." If your day is spent clicking around an IDE, it's an excellent choice.
GitHub Copilot is the standard for autocomplete. It handles snippets well, but its agentic version still lags behind Claude Code and Cursor.
Codex CLI is OpenAI's terminal option. It's younger, with a thinner MCP offering in 2026.
Claude Code wins on pure agentic capability, multi-surface support (terminal, IDE, web, Slack, mobile), MCP, sub-agents and plan mode. It's the tool for teams that want to industrialize their workflow, beyond simply typing faster.
For a detailed head-to-head covering RAM, speed and pricing based on real usage, we have a dedicated comparison: Claude Code vs Cursor.
Pricing and plans in 2026
Anthropic's public pricing is in US dollars. Here's where things stand at the time of writing, checked against the official page.
| Plan | Price | Best for |
|---|---|---|
| Free | $0 | Claude Code not included |
| Pro | $17/month billed annually or $20/month | Solo devs, short sprints |
| Max 5x | $100/month | Heavy daily use |
| Max 20x | $200/month | Power users, long-running projects |
| Team | $20/user/month | Teams of 5 to 150 people |
| Enterprise | Custom quote | SCIM, audit logs, SSO, MSA |
On pay-as-you-go API pricing: Opus 4.7 costs $5/M input tokens and $25/M output, Sonnet 4.6 costs $3 and $15, and Haiku 4.5 costs $1 and $5. With prompt caching, you pay far less for input on repeated context, which matters as soon as your CLAUDE.md starts growing.
The rule of thumb: Pro for 2 to 3 hours of coding a day, Max 5x once you're coding full time, Team for a group that needs centralized admin, and Enterprise for regulated industries. The free plan does NOT include Claude Code, so don't waste time looking for a way to turn it on.
FAQ
Is Claude Code free?
No. Claude Code is included starting with the Pro plan at $17 per month billed annually, or $20 billed monthly. The free Claude plan (claude.ai) doesn't let you use Claude Code. You can also use the Anthropic API on a pay-as-you-go basis if you already have an active developer account.
Which models does Claude Code use in 2026?
Claude Code runs on Anthropic's current Claude models: Sonnet 4.6 for a balance of speed and quality, Opus 4.7 for complex tasks that need advanced reasoning, and Haiku 4.5 for fast, low-cost operations. Your choice depends on your subscription plan, and you can switch models mid-session.
Can Claude Code modify my files without permission?
No. By default, Claude Code asks for permission before any file change or shell command. Read-only operations go through automatically, while writes and Bash commands require approval, which you can make permanent for the session. acceptEdits mode automatically accepts writes, and plan mode blocks all changes until you explicitly approve.
What's the difference between Claude Code and Claude.ai (web)?
Claude.ai is the chat interface in your browser: you paste code in and have a question-and-answer conversation. Claude Code is an agent that lives in your terminal, IDE or desktop: it reads your entire project, edits files, runs commands and makes Git commits. Claude.ai is a consultant you call occasionally, while Claude Code is a developer embedded in your environment.
Can I use Claude Code in VS Code?
Yes. Anthropic publishes an official extension on the VS Code Marketplace, providing inline diffs, @-mentions, plan review and conversation history inside the editor. The same extension works in Cursor. JetBrains IDEs (IntelliJ, PyCharm, WebStorm) have their own plugin on the JetBrains Marketplace.
Is Claude Code safe for proprietary code?
By default, Pro and Max plans aren't used to train models. Team and Enterprise add SSO, access controls, audit logging and advanced compliance. For regulated environments, Claude Code can be routed through Amazon Bedrock, Google Vertex AI or Microsoft Foundry. Hooks also let you programmatically block access to sensitive files.
Will Claude Code replace developers?
No, and that's the wrong question. With Claude Code, the developer's role shifts from doing the work to supervising it as an architect. The developer defines the intent, approves the approaches and reads the diffs. The agent handles the mechanical writing, the tests, the commits and the research. The effect is a multiplier.
