Claude Code

What it is

Claude Code is an agentic coding tool from Anthropic. It reads a codebase, edits files, runs commands, and works with git: staging changes, writing commit messages, creating branches, and opening pull requests. It is a harness in the sense this reference uses the word. The model supplies judgment, and the tool supplies the loop, the file and shell access, the context assembly, and the permission checks.

Two facts frame everything else on this page. It runs Claude models only, and it is not open source: the repository states that use is subject to Anthropic's Commercial Terms of Service. Both matter for an architecture that values replaceability, and both are offset in part by how much of its configuration sits in open, portable formats.

One engine, several surfaces

The tool runs as a terminal CLI, as extensions for VS Code and JetBrains IDEs, inside a desktop app, and on the web, where sessions run in the cloud against repositories you do not have checked out locally. The documentation describes these as surfaces onto the same engine, so a repository's instruction files, settings, and MCP server configuration apply across all of them.

That design choice is the useful lesson for anyone building their own harness. Capability defined once and exposed in several places stays consistent. Capability rebuilt per surface drifts.

Model access and providers

Claude Code uses Anthropic's Claude models. What varies is where inference runs. Besides a Claude subscription or an Anthropic Console account, the documentation covers Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform (formerly Vertex AI), and Microsoft Foundry, plus routing through an LLM gateway for centralized authentication, budgets, and usage tracking.

For the models and routing layer, this is replaceability of the provider without replaceability of the model family. A team can move billing and data residency between clouds; it cannot point the tool at an open-weight model. If model choice per task is a requirement, that is a reason to run a provider-agnostic harness next to it.

Instructions, skills, and hooks

Three mechanisms shape behavior without touching the model.

• CLAUDE.md. A markdown file read at the start of every session, used for coding standards, architecture decisions, and review checklists. If a repository already has an AGENTS.md for other agents, Claude Code can read that instead, which keeps one instruction file serving several harnesses.
• Skills. Folders of instructions and supporting files, loaded when a task matches, used to package repeatable workflows such as a release or a review procedure. The format is the open Agent Skills format described elsewhere in this knowledge base.
• Hooks. Shell commands that run before or after the agent's actions, for example formatting after every edit or linting before a commit. Hooks are enforced by the harness, not requested of the model, which makes them a real control rather than a suggestion.

Organizations can also set managed permissions that local configuration cannot override. That is the bounded property expressed as policy outside the model, which is where it belongs.

Tools and MCP

Beyond its built-in file, search, and shell tools, Claude Code connects to external systems through the Model Context Protocol. The documentation recommends that one team configure MCP servers and check a .mcp.json file into the repository so every developer gets the same connections.

Because MCP is an open protocol, those tool servers are not Claude Code assets. The same server can serve a different harness tomorrow, which is the practical meaning of portable tool access.

Subagents and parallel work

A session can spawn subagents that work on parts of a task at the same time, with a lead agent assigning work and merging results. Several full sessions can also run side by side. The architectural question is the one any concurrent harness has to answer: what is shared between workers and what is isolated. Parallel agents editing one working tree conflict; separate worktrees or cloud sessions keep the work genuinely parallel.

For custom agents, Anthropic publishes the Agent SDK, which exposes the same tools and loop for programs that need their own orchestration and permission rules.

Headless and CI use

The CLI accepts a prompt with -p and runs without an interactive session, so it can be piped into, scripted, and run in CI. The documentation covers GitHub Actions and GitLab CI/CD for review and issue triage. Non-interactive use moves the permission question from a person clicking approve to configuration written in advance, which deserves the same review as any other deployment config.

Where it fits in an open stack

In the four-layer model, Claude Code is an execution-layer harness with a fixed model family. The parts of it that touch other layers are mostly open: MCP for tools, Agent Skills for procedures, AGENTS.md or CLAUDE.md for instructions, and git for the record of what changed.

The practical stance is the one this reference takes toward any single-vendor component: use it where it is strong, and keep the definitions it depends on in formats another harness can read. A team whose skills, tool servers, and instructions are portable can add or replace a harness at the cost of configuration.

Gotchas worth knowing

• Shell access is the permission that matters. A coding agent that can run commands can do what the user can. Decide on containment deliberately.
• Repository content is untrusted input. Issue text, dependency docs, and comments can carry instructions aimed at the agent.
• Provider choice is not model choice. Moving between Anthropic, Bedrock, Google Cloud, and Foundry changes billing and residency, not the model family.
• Pin models on cloud providers. The documentation recommends pinning model versions on third-party platforms so upgrades happen when you decide.
• Instruction files drift. If CLAUDE.md and AGENTS.md both exist with different content, different harnesses will follow different rules.

How it scores on openness

• Replaceable. Weak on models, since it runs Claude only. Moderate on the harness itself when skills, MCP servers, and instructions are kept in open formats.
• Inspectable. Limited. The source is not open, so the loop and system prompts cannot be read directly; transcripts and hooks give partial visibility.
• Portable. Good for skills, MCP configuration, and AGENTS.md. Session history and product settings are less portable.
• Bounded. Good. Permissions, hooks, and managed settings are enforced by the harness rather than by the prompt.
• Grounded. Strong for code, since it works from the repository, command output, and test results.
• Auditable. Good when work lands as commits and pull requests; cloud provider deployments add the provider's own audit logs.

What it is not

Claude Code is not a model. It is a harness that runs Anthropic's models.

It is not open source. It is a commercial product with a public issue tracker.

It is not a broker. It runs its own agent loop and its own subagents; routing work across different harnesses is a separate job.