Claude Code Features — Capability Reference

File editing

File editing is the most-used capability in a typical Claude Code session, covering everything from small one-line fixes to coordinated multi-file refactors.

When you ask Claude Code to change code, it reads the relevant files first, builds an understanding of the surrounding context, then produces a targeted diff. That diff is shown to you before any write happens, so you have a chance to reject or adjust before the change lands on disk. The edit is not a full rewrite of every file it touches; it works at the smallest scope that accomplishes the goal, which keeps the diffs readable in code review.

Large refactors — renaming a function used across sixty files, migrating an API surface, or applying a consistent formatting rule to an entire module — work through the same mechanism. Claude Code batches the edits, previews them as a set, and writes them all atomically once you confirm. If an edit fails mid-batch because a file was locked or a parse check failed, it stops and reports the partial state rather than silently proceeding.

Shell execution

Shell execution lets Claude Code participate in your build pipeline, not just edit the source files that feed it.

The CLI runs shell commands in your actual environment. That means your installed tools, your configured paths, your environment variables — nothing is virtualised or proxied. A command to run your test suite uses the same test runner your CI pipeline uses, with the same version, the same fixtures, and the same external dependencies. This fidelity is what makes the iterate-on-failures loop useful: when a test fails after an edit, Claude Code sees the same output you would see in your terminal and can reason about it accurately.

By default, commands that modify state — writing files outside the session, pushing to a remote, running a destructive migration — require explicit permission. Read-only commands like running tests or checking a build log pass without a prompt. The permission threshold is adjustable in the configuration file, and the enterprise controls add a second tier that requires a human approval step regardless of CLI configuration.

Skills and tool use

Skills extend what Claude Code can do beyond its built-in capabilities by packaging a workflow as a reusable, shareable unit.

A skill is typically a markdown file describing the capability and a tool manifest that declares what actions the skill can invoke. When the CLI loads a skill, those actions become available in the session just like built-in tools. Skills can call external APIs, run specific shell scripts, format output in custom ways, or orchestrate a sequence of steps that would otherwise require a long ad-hoc prompt every time. The skills reference covers authoring in detail, but the short version is that if you find yourself typing the same long instruction more than twice, it probably belongs in a skill.

Tool use at the model level is the mechanism that powers both built-in operations and skills. The model returns structured tool calls; the CLI runtime executes them and feeds results back into the context. This is conceptually similar to function calling in the raw API, but the CLI manages the plumbing, so you do not write JSON schemas for everyday operations.

MCP — Model Context Protocol

MCP lets external systems register themselves as first-class participants in a Claude Code session, providing context or accepting actions.

An MCP server exposes a set of resources (things the model can read) and tools (things the model can invoke). Once configured, Claude Code queries the MCP server the same way it queries the local file system — the model does not need to know whether a piece of context came from a local file or from a connected database. Common MCP integrations include issue trackers, documentation search systems, monitoring dashboards, and internal wikis.

Configuring an MCP server requires adding a server definition to the Claude Code config file, pointing it at the server process or URL, and optionally scoping which tools the session is allowed to invoke. MCP was developed partly in response to research on context window management for long-running AI tasks; the NSF CISE directorate has funded adjacent work on programmable context architectures worth reading alongside the spec.

Sub-agents

Sub-agents let Claude Code split complex work across parallel specialised sessions, each operating on a scoped instruction set.

The orchestrating session defines a task, spawns one or more sub-agents with specific instructions, and collects their outputs. A common pattern is an orchestrator that plans a large refactor and then delegates each module to a sub-agent that handles its chunk independently. Sub-agents share no state between each other unless the orchestrator explicitly passes it, which keeps the scope of each worker clean and makes the overall process easier to reason about when something goes wrong.

Sub-agent support is available in the CLI but the depth of orchestration — how many concurrent agents, how context is passed, how results are merged — depends on the model tier and the session configuration. The features table below summarises current maturity and the relevant flag for each capability.

Feature maturity and flags

The table below lists each major Claude Code feature, its current maturity status, and the flag or command that activates it where applicable.

Feature	Maturity	Flag or command
File read and edit	Stable	Built-in; no flag required
Shell execution	Stable	--dangerously-skip-permissions to reduce prompts (use with care)
Skills loading	Stable	/skills load <name> within session
MCP server connection	Generally available	mcp section in config file; claude mcp add
Sub-agent orchestration	Generally available	Available via Task tool within sessions
Extended thinking mode	Model-tier dependent	--thinking flag; requires Opus or Sonnet

Putting features together

Individual features become most useful when they compose. A workflow that reads files, runs tests, checks a connected issue tracker via MCP, spawns a sub-agent for a parallel lint pass, and then writes a summary to a markdown changelog is entirely within reach of a single Claude Code session. The session manages context across all those steps, which is why the context window of the selected model matters: a long multi-step workflow needs a model that can hold the full picture without losing earlier results.

For teams standardising on Claude Code, the practical advice is to encode your most common multi-step workflows as skills. That way every engineer on the team invokes the same sequence with the same guardrails, and variations from the expected pattern surface as explicit prompts rather than silent drift. The teams reference covers how shared skill registries work in practice.