Anthropic Claude Code — what it is and how it works

Claude Code is Anthropic’s official AI coding tool — a terminal CLI, a set of IDE plugins, and a web interface that all wire the same model into a real engineering environment. Unlike a pure editor plugin, Claude Code is built around autonomous sessions: you describe a goal, the assistant plans, reads files, edits code, runs tests, and reports back. The work happens in long-running loops, not single-line completions.

This article is the overview piece for the cluster. Three companion articles go deeper on the auto-classifier, on MCP server integration, and on the features every user should know.

Who’s behind it

Claude Code is built by Anthropic — the same company behind the Claude model family (Opus, Sonnet, Haiku). That matters in two ways. First, the tool gets first-class access to the latest model behavior, including features like extended thinking, prompt caching, and the 1M-token context window. Second, Anthropic publishes Claude Code as an opinionated reference implementation: it’s how Anthropic itself thinks an AI coding agent should be built.

The CLI lives in your terminal, the plugins integrate with VS Code, JetBrains, and similar IDEs, and the web version runs sessions in a managed environment. Underneath, all three are the same agent loop talking to the same model API.

How it’s different from Copilot or Cursor

Editor plugins like GitHub Copilot or Cursor are optimized for inline completion: you type, the model predicts the next few lines, you accept or reject. That’s a tight, fast loop — and it’s a different problem from “rewrite this module to use the new auth pattern.”

Claude Code is built for the second kind of task:

• Longer sessions. A run can take minutes and touch dozens of files. The agent reads, plans, edits, runs tests, fixes its own mistakes, and reports back.
• Tool-use first. Instead of just emitting text, the model calls tools — Read, Write, Edit, Bash, Grep, and many more. That’s how it interacts with the real filesystem and shell.
• Less inline, more autonomous. You spend less time accepting individual suggestions and more time reviewing finished work.

Both paradigms are valuable. They just solve different problems. Many teams use Copilot for typing and Claude Code for larger refactors, migrations, or feature work.

The three-layer architecture

Under the hood, Claude Code is a three-layer system:

1. The model. Claude Opus, Sonnet, or Haiku — chosen per session based on the task complexity and your plan. The model is the brain: it plans, decides, writes code, debates trade-offs.
2. The tools. Bash, Read, Write, Edit, Grep, Glob, WebFetch, WebSearch, TodoWrite, and a dozen more. Every action the agent takes against the world happens through a tool call. That’s what makes the model useful instead of just conversational.
3. The permission layer. Every tool call passes through a permission check. Some are pre-approved via your allowlist; others prompt for confirmation; risky ones get scored by an auto-classifier before being allowed through.

This separation is what makes the system safe enough to run against a real production repo. The model can ask to do anything — but the permission layer decides what actually executes.

MCP, the auto-classifier, and the permission system

Three pieces extend the basic architecture and deserve their own articles.

• MCP (Model Context Protocol) is the standard way Claude Code talks to external tools — databases, issue trackers, internal APIs. See the MCP article for the wiring details.
• The auto-classifier is a small LLM that scores risky tool calls live before they run. It blocks state-machine violations and unsafe writes that the user didn’t explicitly authorize. Full treatment in the auto-classifier article.
• The permission system lets you tune the trade-off between safety and speed: /permissions allowlists, plan mode, accept-edits mode, and bypass mode. Covered in the features article.

Who it’s for

Claude Code is built for people who already know how to ship software and want a capable assistant for the heavier work: refactors, new features in established codebases, migrations, exploratory debugging, documentation, test scaffolding. It’s not aimed at non-developers — the tool assumes you can read its output critically and intervene when it goes off-track.

If you write code daily and spend meaningful time on tasks that take 30+ minutes, this is a tool worth learning properly. Start with this overview, then read the three companion articles to understand the safety model, the MCP integration, and the day-to-day features that pay off fastest.