How a session actually goes
You run it inside a project and describe what you want. It explores the codebase to find the relevant files itself, rather than requiring you to add them — which is the practical difference from Aider, where file selection is your job.
It proposes changes, applies them, runs tests or a build, reads the output, and iterates on failures. A task like “make the test suite pass on Windows” is a coherent instruction rather than a series of them.
The loop is worth understanding because it explains the cost: each step re-reads context, so a long task on a large repository consumes considerably more than a chat exchange. That is inherent to agents, not specific to this one.
CLAUDE.md, and why it matters more than it looks
A file called CLAUDE.md in the repository is read automatically at the start of every session. It holds project conventions, the commands that build and test, architectural constraints, and anything else a new contributor would need told.
This is the highest-leverage thing in the tool and the most commonly skipped. Without it you re-explain your conventions every session and get output that ignores them. With it, “we use pnpm not npm”, “never edit files in `generated/`”, “run `make check` before claiming done” are stated once and applied consistently.
It is also a team artefact. Committed to the repository, it means every developer’s agent behaves the same way — which is not achievable with per-developer tool configuration, and is a real argument for this tool in a team setting.
Permissions and hooks, or how much rope to give it
Claude Code asks before running commands that touch your machine. The permission system lets you pre-approve patterns you trust so a session is not a stream of prompts.
This is the setting that decides your risk. Loosened carelessly, an agent that runs commands can delete files, force-push, or run a migration against the wrong database. Tightened, you approve everything and lose the point of an agent.
The sensible position: pre-approve read-only and routine build commands, never pre-approve anything destructive or anything that touches a remote, and keep the loosest configuration for throwaway sandboxes rather than for your main repository.
Hooks run before or after tool use — a formatter after every edit, a check that refuses commits to the default branch, a notification when a long task finishes. They are how you enforce a rule rather than requesting it.
MCP, and reaching past the filesystem
The Model Context Protocol connects it to systems beyond your files: issue trackers, databases, documentation, internal APIs, browser automation.
The difference this makes is between an agent that edits code and one that completes a task. Reading the ticket, checking the live schema before writing a migration, or consulting current API documentation rather than recalling it are the steps that otherwise fall back to you.
It also widens what a mistake can reach. An MCP server with write access to a database is a larger blast radius than file access, and the permission model is what stands between them. Grant narrowly and prefer read-only connections where they suffice.
Subagents and parallel work
It can spawn subagents for work that decomposes — searching a large codebase, or handling independent pieces of a task concurrently. Each starts without your conversation’s context, which is both the point (they do not inherit irrelevant history) and the limitation (they must be briefed).
This matters most on large repositories where exploration is the slow part.
The single-provider trade
Claude Code runs Anthropic’s models only. There is no bring-your-own-key, no local model, no fallback.
That is the central trade-off against Cline and Aider, which accept any provider. What you gain is tighter integration — the harness is built around specific model behaviour rather than a lowest common denominator. What you lose is the ability to switch when pricing changes, to use a cheaper model for mechanical work, or to run anything offline.
For an individual that is a preference. For an organisation standardising on it, it is a concentration decision worth making deliberately.
Processing and provider concentration
Code is sent to Anthropic’s API for processing. There is no local option, so this tool is unsuitable where source may not leave the network.
Anthropic publishes its data handling and retention terms, and commercial agreements differ from consumer ones. Read the current version rather than a summary — including this one.
What it takes to run
- Node.js, then installation via npm. macOS, Linux, or Windows.
- An Anthropic account — access through a Claude subscription or API billing. No free tier.
- An internet connection; the models are hosted.
- Comfort with a terminal, and the judgement to review what an agent proposes.
- Optionally: a `CLAUDE.md`, MCP servers, and a considered permission configuration. All three repay the setup time.
Beyond the terminal
It is also available as a desktop application, IDE extensions for VS Code and JetBrains, and a web interface — all driving the same underlying agent.
The terminal remains the idiom, and the other surfaces are best understood as different windows onto the same tool rather than as separate products. If you dislike terminals, they help; they do not make it an editor.
Who works well this way
Developers comfortable in a shell who want an agent rather than autocomplete — particularly for work spanning many files, or tasks defined by an outcome rather than an edit.
Teams that benefit from `CLAUDE.md`: conventions written once and applied consistently by everyone’s agent.
Anyone whose work involves systems as well as code, where MCP turns a coding tool into something that can finish a ticket.
Less suitable for people who mainly want faster typing, for anyone unwilling to depend on one provider, for air-gapped environments, and for developers who want inline completion — it has none, and most users run something else alongside.
What the harness gives you
- It finds its own context — no manually adding files before it can start.
- Editor independence. Works the same with Vim, JetBrains or VS Code.
- Project conventions persist through `CLAUDE.md`, as a committed team artefact.
- Extensible reach via MCP, so it can act on systems outside the repository.
- Configurable autonomy — permissions and hooks let you decide what runs unattended.
- Subagents for parallel exploration on large codebases.
What you accept in return
- One provider. No local models, no alternatives, no fallback.
- Paid only, with cost scaling with use; agentic sessions consume far more than completion tools.
- No inline completion, so it is rarely the only tool installed.
- Autonomy needs supervision. Loose permissions plus a confident agent is where real damage happens.
- Terminal-first, which suits some developers and not others.
- Hosted only — unsuitable for restricted environments.
If you stop using it
Your repository is unaffected — changes were committed as you went, and there is no proprietary state in the project.
`CLAUDE.md` is plain markdown and remains useful documentation regardless; several other tools read project instruction files, so the effort is not wasted. MCP server configurations are portable in principle, since MCP is an open protocol rather than a proprietary one.
What does not transfer is conversation history. Exit cost is low, which is the usual position for tools that do not hold your data.
Model-agnostic equivalents
- Aider — the closest open-source equivalent, model-agnostic and git-centric.
- Cline — the same pattern inside VS Code, with your choice of model.
- Cursor IDE — an editor with an agent built in, plus completion and indexing.
- GitHub Copilot — completion-first, with agent features added later.
Compiled from Anthropic’s Claude Code documentation and public sources. We have not hands-on tested this tool. Last reviewed 16 August 2026.
