Claude Code is Anthropic's agentic coding tool, and what sets it apart from the editor-based assistants is where its centre of gravity sits. It started in the terminal, and it now runs in several places — the terminal, IDE extensions for VS Code and JetBrains, a desktop app, and the browser — but every one of them drives the same engine, and that engine is built around the environment, not the editor. That sounds like a detail until you use it, at which point the logic becomes obvious. The shell is where the code already gets built, tested, committed, and deployed — so an agent that can work there does the whole job, not just the typing, whichever window you happen to be looking at it through.

This is the coding-agent pattern in its most direct form: a model, a set of tools, and the act-observe-act loop, pointed at a real repository.

What it does in one sentence#

You describe a change; Claude Code reads the relevant files, edits across as many of them as the change requires, runs the tests or the build, reads the output, and iterates until it works — showing you what it is doing as it goes.

The crucial part is the loop closing on a real oracle. It does not write code and hope. It runs the suite, sees the failure, and fixes it, exactly as you would. That is the difference between a tool that drafts and a tool that finishes, and it is why coding was the first agentic domain to genuinely land: the environment tells the truth, and the agent can hear it.

How it works, concretely#

Give it a task and a predictable sequence follows:

Text
you:    "the /me/bookmarks page 500s when a saved post is deleted — fix it"

Claude Code:
  - greps for the bookmarks controller and view
  - reads how the relation is used
  - notices the post relation resolves to null after a soft delete
  - edits the controller to guard the query
  - runs the test suite
  - reads a failure, adjusts, runs again — green
  - shows you the diff

It is not guessing at your codebase from a stale training snapshot. It reads the actual files, runs the actual commands, and reacts to the actual output. When it is wrong, it is wrong about your code in front of you, where you can see it — not silently in a suggestion you have to vet line by line.

The features that matter for real work#

Beyond the core loop, a handful of capabilities separate "impressive demo" from "in the daily workflow":

  • It runs your commands. Tests, linters, builds, git, the deploy script — with your permission. This is what lets the loop close. An agent that can write a test but not run it is back to drafting.
  • MCP — the Model Context Protocol. The open standard that lets it reach beyond the filesystem: your issue tracker, your database, your monitoring, any tool exposed over MCP. It is the connective tissue of the current agent ecosystem, and Claude Code speaks it natively.
  • Subagents and parallelism. Hard problems can be fanned out — several agents reviewing different dimensions of a change, or exploring in parallel — and their findings synthesised. Most tasks do not need this; the ones that do benefit a lot.
  • Hooks. Deterministic commands the harness runs at defined points — before a commit, after an edit — so policy is enforced by the tooling rather than by asking the model nicely. If you need something to always happen, a hook is how, because the model's good intentions are not a guarantee.
  • Plan mode. It works out an approach and shows you before it touches anything. For a large or risky change, seeing the plan first is the difference between supervising and cleaning up.

The mental model that makes it click: treat it like a fast, capable colleague who has just joined and does not yet know your conventions. Point it at the code, let it read, and correct it early when it drifts. The engineers who get the most from it are not writing longer prompts — they are giving it the tools to check its own work and reviewing the diff, exactly as they would a human's pull request.

What it is genuinely good at, and where to watch it#

Honest boundaries, because a tool sold as magic teaches you nothing:

Strong: well-specified changes in a codebase with tests. Bug fixes with a clear repro. Mechanical refactors across many files. Wiring up something new against an existing, well-worn pattern. Reading an unfamiliar codebase and explaining it. The common thread is a cheap oracle — a test, a type checker, a repro — that lets the loop self-correct.

Watch it: changes with no way to verify correctness cheaply, where it will produce confident, plausible code you have to check entirely by hand. Sprawling, underspecified tasks where the lack of a clear goal shows up as flailing. Anything where "it compiles and the tests pass" is not the same as "it is correct" — subtle concurrency, security-sensitive logic, a public API's contract. The tool is a fast writer of code that satisfies the checks you give it, which is a different thing from code that is right, and the gap is yours to close.

Run locally, it runs commands on your machine. That is the source of its power and the thing to be deliberate about: review what it proposes to run, and do not point it at production credentials or a live system on the assumption it will be careful. It is careful about the task; it is not a substitute for the controls you would put around any process that can execute code and touch your infrastructure. Give it a branch, not the deploy key.

Where it fits#

Claude Code belongs to the same family as the terminal agents and IDE assistants covered in the examples survey, and it makes the family's strongest bet: put the agent where the whole software lifecycle happens — the shell, the repository, the test suite — and then meet the engineer wherever they work, in the terminal, the IDE, the desktop app or the browser, give it the tools to check its own work, and get out of its way on the mechanical parts so the engineer spends their attention on the parts that need judgement. Used that way — as a fast pair who does the tedious 80% and hands you the diff — it is one of the clearest cases of agentic AI paying for itself today. Used as an oracle you trust blindly, it is a very efficient way to ship confident mistakes. The tool is the same; which one you get is down to how you hold it.

Sources#

  • Claude Code overview — what Claude Code does: reads the codebase, edits files, runs commands, connects tools over MCP; available in the terminal, VS Code and JetBrains, a desktop app and the browser, all on the same engine.
  • Configure permissions — shell commands and file edits require approval by default.
  • Automate actions with hooks — hooks as deterministic shell commands at lifecycle points, rather than relying on the model.
  • Create custom subagents — subagents running in their own context and returning a summary.
  • Common workflows — plan mode: reads and proposes a plan, no edits until approved.
  • Introducing the Model Context Protocol — MCP as an open standard for connecting AI systems to tools and data.