Claude Code is Anthropic's agentic coding tool, and it makes a deliberate choice that sets it apart from the editor-based assistants: it lives in the terminal, not the IDE. That sounds like a downgrade until you use it, at which point the logic becomes obvious. The terminal is where the code already gets built, tested, committed, and deployed — so an agent that lives there can do the whole job, not just the typing.

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.

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, 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.