Claude Code – Anthropic's CLI coding agent deep dive

Claude Code is Anthropic's command-line coding agent: a tool that runs in your terminal, reads and writes files in your actual repository, runs commands, and works through multi-step software tasks under a Claude model. It is not a chat window that hands you snippets to paste. As of early 2026, it is generally available through Anthropic's API and via Claude subscription plans, and it sits alongside a growing field of agentic coders. The short version, before the detail: it is a strong tool in the hands of an engineer who already knows what good looks like, and a liability in the hands of someone who does not. The rest of this piece explains why, based on using it on real work rather than reading the documentation and guessing.

The examples below come from hands-on sessions on ordinary production-adjacent code – a Python module, a Node service, a debugging task, a test-writing task – run against Claude Code as it stood in early 2026. Model versions, pricing, and defaults move constantly on this beat, so verify anything specific against Anthropic's official Claude Code documentation before you make a purchasing or architecture decision on it.

What Claude Code is (and isn't)

Claude Code is a terminal application. You install it, point it at a directory, and give it instructions in natural language. It then plans, edits files, runs shell commands, inspects output, and iterates – all within the working tree of your project. It is built on Anthropic's Claude model family, defaulting to the Sonnet tier for most work and offering the Opus tier for harder reasoning, with the exact model names and availability changing across releases. If you want the underlying model lineage, we cover it separately in Claude, the model family explained.

What Claude Code is not matters as much as what it is. It is distinct from Claude.ai, the consumer chat product where you converse in a browser and copy code out by hand. It is distinct from the raw Claude API, which gives you model access with no agent scaffolding, no file editing, and no tool loop – you build all of that yourself. And it is distinct from Claude Skills, Anthropic's framework for packaging reusable tool behaviours. Claude Code is the opinionated, batteries-included agent that ties the model to your filesystem and shell. That coupling is the whole point, and it is also the source of most of the risk.

The company behind it has built its brand on caution, which shapes the product's defaults. Its posture is worth understanding in context, which we set out in Anthropic, the company and the safety-first approach.

How Claude Code actually works

Under the surface, Claude Code is a tool-use loop. The model is given a set of tools – read a file, write a file, run a shell command, search the codebase, list directories – and it decides, turn by turn, which to call. When you ask it to add a feature, it does not hallucinate the entire change in one shot. It reads the relevant files, reasons about them, proposes edits, applies them, often runs your tests or a build, reads the result, and corrects. This tool-calling pattern is the same mechanism that underpins most modern agents, and it is closely related to the interoperability work described in the Model Context Protocol explained; Claude Code can consume MCP servers to reach external systems beyond the local shell.

What it indexes, and what it doesn't see

Claude Code does not pre-index your entire repository into a vector database the way some IDE tools do. It explores on demand. When you give it a task, it uses search and file-reading tools to pull the parts of the codebase it judges relevant into the model's context window. This is efficient for large repositories – it does not need to embed millions of lines up front – but it means the agent only knows what it has bothered to look at. If a critical constraint lives in a file the agent never opened, it will not know about it. In practice you learn to point it at the right places, or to maintain a project instructions file that tells it where the important context lives.

The interaction model follows a rough rhythm: instruction, plan, execute, review. You state what you want. The agent frequently outlines a plan before touching anything, especially for larger tasks. It then executes, editing files and running commands. Finally it reports what it changed, and you review the diff. The review step is not optional theatre. It is the point at which a competent engineer catches the twenty percent of changes that are subtly wrong.

The permissions boundary

Because Claude Code can run shell commands and modify files, Anthropic puts a consent boundary in the way. By default the agent asks before running commands or making edits that could be destructive, and you approve or deny each action. You can loosen this – grant standing permission for certain command classes, or run in a more autonomous mode – and the temptation to do so grows with familiarity. Resist it on anything that touches production credentials, deletes files, or runs against live infrastructure. The "are you sure?" prompt is the difference between a bad suggestion and a bad suggestion that has already deleted your migrations. Treat sandboxing and least-privilege as seriously here as you would with any process that has shell access, a point that overlaps with the concerns in AI cybersecurity threats and adversarial AI.

Real evaluation – what we tested

Abstract praise is worthless for a tool like this. What follows is drawn from four concrete tasks on real code, with honest outcomes. Times and acceptance rates are approximate and specific to these runs; your mileage will vary with codebase quality, task clarity, and model version.

Task 1: Refactor a 200-line Python module

The module was a tangle of nested conditionals in a single function, with duplicated logic and no type hints. The instruction was to break it into smaller functions, add type annotations, and preserve behaviour exactly. Claude Code read the file, proposed a decomposition, and produced a clean refactor in a few minutes of wall-clock time. Roughly nine-tenths of the change was accepted as written. The remaining tenth needed correction: it had changed one edge-case behaviour by "simplifying" a condition that was deliberately awkward. Because the module had tests, the regression surfaced immediately. Without tests, it would have shipped. Verdict: strong, but the failure mode was exactly the kind that looks correct.

Task 2: Add a feature to a multi-file Node project

This was the harder test – an Express service where a new endpoint required touching a route file, a controller, a validation schema, and a data-access layer. Claude Code handled the cross-file coordination well, which is where autocomplete-style tools fall apart. It found the existing patterns, matched the project's conventions, and wired the pieces together. Two problems emerged. It introduced a validation library import that the project already had a different convention for, and it wrote the data-access call against a method signature it had guessed rather than verified. The first was a style issue; the second was a real bug caught on the first run. Total time including review and fixes was well under what the change would have taken by hand, but not the "walk away and it's done" experience the marketing around agentic coding tends to imply.

Task 3: Debug an issue in code Claude didn't write

An intermittent test failure in unfamiliar code. Here the agentic loop shone. Claude Code read the failing test, traced the call path, formed a hypothesis, added logging, ran the test, read the output, and narrowed the cause to a race in async initialisation. The diagnosis was correct and arrived faster than a cold read by a human would have. The proposed fix was reasonable but conservative; a senior engineer chose a cleaner approach after understanding the root cause the agent had surfaced. The value here was investigation, not the patch.

Task 4: Generate tests for an existing module

Test generation is where these tools are both most useful and most seductive. Claude Code produced a broad suite quickly, with good coverage of the obvious paths. But a meaningful share of the tests asserted the current behaviour rather than the correct behaviour – they would pass whether or not the code was right, because they were reverse-engineered from the implementation. That is the classic tautological-test trap, and no coding agent is immune to it. The tests were a strong starting scaffold that needed a human to inject actual intent about what should be true.

The through-line across all four: Claude Code is excellent at the mechanical and investigative work, and it is confidently wrong just often enough that unreviewed output is dangerous. For an independent read alongside your own testing, Simon Willison's ongoing writing on Claude and agentic coding tools is among the more clear-eyed developer accounts, and worth reading before you commit a team to any workflow.

Pricing and cost reality

Pricing is the part of this article most likely to be out of date by the time you read it, so treat the following as directional and confirm against Anthropic's current pricing page and the Claude Code documentation.

As of early 2026, Claude Code can be used in two broad ways: metered through the Anthropic API, where you pay per token consumed, or bundled into Claude's paid subscription tiers, which include a usage allowance for Claude Code within a monthly fee. The economics diverge sharply depending on how you work. Token-metered use on a heavy day of agentic work – many multi-file tasks, lots of file reading, repeated test runs – can accumulate real cost, because the agent's read-heavy exploration burns input tokens and the Opus tier is materially more expensive than Sonnet. A single day of the four-task workload above, run largely on Sonnet, lands in the low-single-digit dollars to low-tens-of-dollars range depending on repository size and how much the agent re-reads; push everything through the Opus tier on a large codebase and that figure climbs quickly.

Against the alternatives, the comparison is not apples to apples. GitHub Copilot is a flat monthly subscription for autocomplete plus a chat mode, cheap and predictable, but a fundamentally lighter-weight tool. Cursor sells a subscription with usage tiers and its own model routing, sitting between Copilot's simplicity and Claude Code's agentic depth. Aider is open source and free as software, but you pay the underlying model API costs directly, which for Claude models means roughly the same token economics as running Claude Code through the API. The honest summary: if your work is autocomplete-shaped, Copilot is far cheaper; if it is agentic and multi-file, Claude Code's cost is defensible against the engineering time it saves, provided you monitor spend and default to Sonnet. Watch for rate limits under heavy automation, a failure mode we cover in 429 Too Many Requests and OpenAI rate limit errors – the pattern generalises across providers.

Where Claude Code excels

The Claude models' long-context handling is the foundation of the product's best behaviour. When a task spans many files and depends on understanding how they interact, Claude Code holds more of that structure coherently than autocomplete tools can. Multi-file refactors are its strongest suit: renaming a concept across a codebase, extracting a shared module, threading a new parameter through a call chain. These are the tasks that are tedious and error-prone by hand and that break tools which only see the current file.

It is also unusually faithful to written specifications. Give it a precise, well-structured instruction – or better, a project instructions file describing conventions, constraints, and preferences – and it follows them closely. This rewards engineers who can specify clearly and punishes vague prompting. The quality of the output tracks the quality of the instruction more tightly than casual users expect.

Where Claude Code struggles

The model's knowledge has a training cutoff, so genuinely new libraries and freshly changed APIs are a weak point. Claude Code will confidently call a method that was renamed in a recent release, or use a deprecated pattern, because the newer reality was not in its training data and it did not think to check the installed version. Pointing it at current documentation or the actual installed source mitigates this, but you have to know to do so.

Performance-sensitive code is another soft spot. It writes correct code readily; it does not reliably write fast code, and it rarely reasons about allocation, cache behaviour, or algorithmic complexity unless explicitly prompted. And any task that depends on knowledge the agent simply does not have – your undocumented business rules, the reason a particular hack exists, the operational history of a system – is beyond it by definition. It cannot see what is not in the code or the context you give it. That gap is where the "senior engineer in the loop" requirement stops being advice and becomes a hard constraint.

Claude Code vs. the alternatives in 2026

The agentic coding field has segmented into distinct paradigms, and choosing well means matching the paradigm to your work rather than chasing benchmark scores. For grounding on how to read those scores in the first place, see AI benchmarks – MMLU, GPQA, LMSYS Arena explained.

Cursor is an IDE, a fork of VS Code with deep model integration. It keeps you in a graphical editor with inline suggestions, chat, and its own agent mode. If you want AI woven into a visual editing experience, Cursor is the more natural home; Claude Code deliberately lives in the terminal and assumes you are comfortable there.

GitHub Copilot remains the autocomplete standard – fast, cheap, ubiquitous, and excellent at the next-line prediction that fills most of a working day. It is not trying to be an autonomous agent in the way Claude Code is, though its agent features have grown. For many developers the right answer is Copilot for flow and a heavier agent for the hard multi-file jobs.

Aider is the closest philosophical cousin: an open-source, terminal-based, git-aware coding agent that you point at model APIs of your choice, including Claude models. Aider gives you more control and transparency and no subscription lock-in, at the cost of more setup and a rougher edge. Engineers who want to own their stack often prefer it; those who want a polished, supported experience lean to Claude Code.

OpenAI Codex CLI is the most direct competitor – a terminal agent from OpenAI in the same shape, backed by OpenAI's models. The choice between them often comes down to which model family you trust more on your kind of code and which pricing suits your usage. We analyse it in depth in OpenAI Codex CLI, the agentic coder analyzed.

Devin occupies the far end of autonomy – marketed as an autonomous software engineer that takes a ticket and runs, rather than a tool you drive turn by turn. That ambition brings a different risk profile and a different failure surface, which we examine in Devin, Cognition's autonomous software engineer. Claude Code is more interactive and more supervised by design, which is a feature, not a limitation, for teams that value control. The broader movement across all of these is tracked in our AI agents news and developments coverage.

When to use Claude Code in production teams

For a solo developer, Claude Code is close to ideal. You are already reviewing everything, you hold the full context of your own project, and the agent multiplies your throughput on exactly the tedious multi-file work you would otherwise do by hand. The cost is manageable if you default to the Sonnet tier and reach for Opus only when a task genuinely needs it.

The strongest team pattern is the senior-engineer-with-Claude-Code workflow. An experienced engineer specifies tasks precisely, lets the agent do the mechanical execution, and reviews every diff with the scepticism the tool earns. In this configuration the agent is a force multiplier that turns a senior engineer's judgement into more shipped work without diluting it. The review is where quality is enforced, and a senior reviewer catches the confident errors that would otherwise reach production.

The anti-pattern is handing Claude Code to a junior engineer as a code generator. The failure modes documented above – subtly changed behaviour, guessed signatures, tautological tests, deprecated API calls – are precisely the ones a junior engineer is least equipped to catch, because catching them requires the experience the agent is supposedly substituting for. Used that way, it produces code that compiles, passes review superficially, and carries latent defects, while quietly preventing the junior engineer from developing the judgement they need. The tool does not raise the floor of a team's capability; it amplifies whatever judgement is already there. That amplification cuts both ways, and it is the single most important thing to understand before deploying Claude Code at scale.

The practical takeaway is unglamorous and durable: Claude Code is a genuinely good agentic coding tool with real, specific limits, best deployed where competent human review is already the norm. Treat the output as a fast, capable draft from a colleague who is brilliant, tireless, and occasionally confidently wrong – and check its work accordingly.