Claude Code

Claude Code is what Anthropic ships to put Claude inside the development loop instead of beside it — an agent that lives in the terminal, understands the repo, and does the work rather than handing back a snippet to paste. This page is the orient-and-decide surface — the official docs at code.claude.com own the CLI flags, the settings schema, and the exact model IDs, all of which move faster than any page here should mirror. It's the one tool on this shelf marked applied, not watching: it's the daily driver here, run every day on a Claude Max subscription.

What it is

An agentic coding tool that reads your codebase, edits files, runs commands, and calls your other tools — terminal-first, but also available as VS Code / JetBrains extensions, a desktop app, and a browser surface, all sharing one engine (your CLAUDE.md, settings, and MCP servers carry across every surface). Point it at a task in plain language and it plans an approach, writes and modifies code across multiple files at once, runs the tests, reads the failures, iterates, and commits — without you naming which files matter or which functions change.

It runs on Anthropic's Claude model family (an Opus-tier model as the default driver, with Sonnet and Haiku tiers available for cheaper or faster work — the docs own the current IDs). The thing that separates it from an autocomplete is the agency: it's a loop that acts on the repo and checks its own work, not a prompt box.

When to use

Reach for it when:

• You want the agent in the terminal, in the repo, driving git, tests, and shell directly — not a chat window you copy out of. It stages changes, writes commit messages, opens PRs.
• You run an all-day, many-repos workflow and you're on Claude Max — flat-rate means the marginal cost of the next session is $0, so there's no per-token anxiety throttling how much you lean on it (see Where it fits).
• The task spans many files or many steps — a refactor, "write tests for this module and fix the failures," a dependency bump across the tree — where the plan-edit-run-iterate loop earns its keep.
• You want to wire in your own context and tooling — CLAUDE.md for house rules, MCP servers for external data, hooks for format-on-edit, skills for shared team workflows, subagents for fan-out.

Skip it when:

• The work is a one-shot question or a single-file tweak — the agent loop is overhead a plain chat handles faster and cheaper.
• The code cannot leave the machine — Claude Code sends your files to a closed cloud model. For data-stays-home work the answer is a local model, not this (see Risks).
• You're optimizing for a hard $0 and you're not already paying for Max — a subscription is still a subscription; the genuinely-free path is Aider on local Ollama.
• You want vendor neutrality or an open, self-hostable stack — this is a single-vendor tool tied to Anthropic's models and cloud.

At a glance

Surfaces (one engine behind all of them)

Surface	What it's for
Terminal CLI	The full-featured driver — the default here. Composable, scriptable, pipeable (tail log | claude -p "…").
VS Code / JetBrains	Inline diffs, @-mentions, plan review inside the editor.
Desktop app	Visual diff review, multiple sessions side by side, kick off longer runs.
Web / mobile	Browser sessions on repos you don't have locally; check back when a long task finishes.

Capabilities that matter for a build

Capability	What it buys you
Agentic multi-file edits	Plans, edits across files, runs tests, iterates — the core loop.
MCP servers	Connect external data/tools (Drive, Jira, Slack, custom) via the open Model Context Protocol.
CLAUDE.md + memory	Persistent house rules and learnings read at the start of every session.
Hooks	Shell commands before/after actions — format-on-edit, lint-before-commit.
Slash commands + skills	Packaged, shareable workflows (/review-pr, /deploy-staging).
Subagents / background agents	Fan a task out across parallel agents; watch several full sessions from one screen.
Plan mode	Review the agent's plan before it touches anything.
Agent SDK	Build fully custom agents on Claude Code's tools and permissions.

Exact model IDs, the current pricing ladder (Pro / Max tiers), and the CLI/settings contracts live in the official docs and claude.com/pricing — treat those as canonical over any number quoted here, which will drift.

Where it fits

This is the daily driver, and the economics are the whole reason. Run on a Claude Max subscription — a flat monthly fee, not metered API — the marginal cost of a session is $0. That's the operator's edge: for someone in the tool all day across many repos, all-you-can-use at a fixed price beats a metered tool where every token is a decision, every long agentic run a line item you feel. The hard rule here makes it cleaner: no metered Anthropic API — Max subscription plus local Ollama, nothing pay-per-token.

The posture is deliberately terminal-first and local-first. Claude Code has grown a lot of cloud surface — hosted routines, remote/background agents, scheduled runs on Anthropic's infrastructure — and those are real capabilities, but they're not the lane here: work runs locally against the subscription, not on managed cloud infra or metered calls. The value being bought is a frontier agent on a flat-rate plan, not a hosted agent platform.

And it's weighed honestly against the free floor. When code can't go to a cloud model, or when $0-and-fully-local is the requirement, the tool isn't Claude Code — it's Aider driving a local Ollama model. Claude Code wins on raw capability and the flat-rate-all-day math; the local path wins on cost-to-zero and data never leaving the box. Knowing which axis a given task sits on is the whole call.

Gotchas

• "Flat rate" still has rate limits. Max is all-you-can-use within limits, not infinite — heavy parallel/background use can hit a ceiling and make you wait. The $0-marginal framing is about per-token anxiety, not an unbounded tap.
• Auto-update and surface sprawl. Native installs update themselves and the tool ships new surfaces (web, desktop, channels, routines) fast — great for capability, but the thing you learned last month has more knobs this month. Pin what your workflow actually uses.
• CLAUDE.md is load-bearing and easy to overgrow. The agent reads it every session; a bloated or contradictory instruction file quietly degrades every run. Curate it like code, not like notes.
• The cloud surfaces are a different cost/trust model. Hosted routines and remote agents can run on Anthropic infra and may bill differently from the flat Max seat — don't assume "it's Max, it's free" carries over to every surface. Check before leaning on the hosted paths.

Risks

• Data leaves the machine. Every session ships your code to a closed, cloud-hosted model. That's the headline risk for anything sensitive, not a footnote — gate hard on which repos are allowed over the wire, and keep the truly private ones on a local model.
• Single-vendor, closed dependency. The whole loop is tied to Anthropic's models, cloud, and pricing. A model change, a limit change, or a pricing change is theirs to make — and there's no self-hostable substitute for the frontier capability, only the lower-capability local path.
• Subscription lock-in on the workflow. Building house rules, skills, hooks, and MCP wiring around Claude Code makes it sticky. Portable by design (CLAUDE.md, MCP, the Agent SDK are open-ish), but the day-to-day muscle memory is the real switching cost.

Related

• Cursor — the dominant AI editor; GUI-first where Claude Code is terminal-first.
• Aider — the open-source, $0, local-Ollama alternative when you can't send code to a cloud model.
• Grok Build — xAI's coding agent, drawn into focus by the SpaceX/Cursor acquisition.
• Ollama — the local-LLM substrate behind the $0, data-stays-home path Claude Code is measured against.