Claude Code is Anthropic's agentic coding tool: a terminal-native agent that reads your codebase, plans multi-step changes, edits files, runs tests, and iterates until the task is done. With the Claude 5.5 family — Opus 5.5 for long-running agentic work, Sonnet 5.5 for everyday tasks, and Haiku 5.5 as a fast subagent — it has become the reference implementation of what "agentic coding" means in practice: not autocomplete, but a colleague that takes a ticket and returns a pull request.
For enterprise teams, the question is no longer whether the model is good enough — it demonstrably is for a large class of work — but how to deploy it with the permissions, memory, and governance a real organization needs. This guide covers the working mechanics: the agentic loop, CLAUDE.md, subagents, MCP servers, and the controls that keep an autonomous agent inside your risk envelope.
The Agentic Loop
A coding agent differs from a chat model in one essential way: it runs a loop, not a single completion. Given a goal, Claude Code gathers context (reading files, searching the codebase, checking git history), forms a plan, executes it with tools (file edits, shell commands, test runners), observes the results, and repeats until done or blocked. Adaptive thinking lets the model spend more reasoning effort on hard steps — architecture decisions, subtle bugs — and less on mechanical ones.
The practical consequence: the quality of a Claude Code session is determined less by prompting skill and more by context design — what the agent can see, which tools it can call, and how clearly the task and its acceptance criteria are stated.
CLAUDE.md: Persistent Project Memory
CLAUDE.md files are the mechanism that turns a general-purpose agent into a team member that knows your conventions. Checked into the repository (or placed at user level for personal preferences), a CLAUDE.md file is loaded into context on every session and typically contains:
- Build and test commands — how to run, lint, and verify the project so the agent can self-check its work.
- Architecture notes — module boundaries, naming conventions, which patterns are used and which are banned.
- Workflow rules — commit message format, branch naming, "always run the test suite before finishing."
- Domain context — glossary entries, regulatory constraints, links to internal docs.
Teams that invest in CLAUDE.md get consistently better output because the agent stops re-discovering conventions every session. Treat it like onboarding documentation — because that is exactly what it is.
Subagents: Parallelizing the Work
Subagents are isolated Claude instances that the main agent spawns for well-scoped subtasks — each with its own context window, its own system prompt, and often a cheaper, faster model (Haiku 5.5 is designed for exactly this role). Typical uses:
- Exploration agents that search a large codebase and report back a summary instead of flooding the main context with file contents.
- Specialist agents — a "test-writer," a "security reviewer," a "docs updater" — each tuned for one kind of output.
- Parallel implementation — independent modules worked on simultaneously, merged by the orchestrating agent.
The mental model is a tech lead delegating to junior engineers: the orchestrator keeps the plan and the acceptance criteria; subagents execute narrow tasks and return concise results. This keeps the main context window — the scarce resource — focused on decisions rather than raw search output.
MCP: Connecting the Agent to Your Systems
The Model Context Protocol (MCP) — open-sourced by Anthropic and now the de facto standard for agent-tool integration — is how Claude Code reaches beyond the filesystem. An MCP server exposes tools (actions the agent can call), resources (data it can read), and prompts (reusable templates) over a standard JSON-RPC interface, running either as a local process (stdio) or a remote HTTP service.
Common enterprise MCP servers include database clients, internal API gateways, issue trackers, observability platforms, and documentation search. The result: instead of pasting a stack trace into a chat, you ask the agent to "find the error in production logs and open a fix" — it queries your monitoring MCP server, correlates the trace to code, and proposes the patch.
A real-world example from our own portfolio: the Stellar Go CLI ships an MCP server that exposes wallets, payments, SEP-41 assets, W3C DIDs, and Soroban RPC as agent tools — so a Claude Code session can build and test a Stellar payment flow end-to-end without leaving the terminal. Any internal system can be wrapped the same way.
Permissions, Hooks, and Safety
Autonomy needs boundaries. Claude Code's permission model gates tool calls — file writes, shell commands, network access — behind allowlists configured per project or per organization:
- Permission modes — from "ask before every action" to scoped auto-approval (e.g., always allow
npm test, never allowrm -rfor pushing to main). - Hooks — user-defined commands triggered on events (before a tool call, after an edit) for policy enforcement, logging, or auto-formatting.
- Sandboxing — OS-level filesystem and network isolation for runs that need stronger containment.
- Audit trail — every tool call and file change is recorded, giving security teams a reviewable history.
Rolling It Out in an Enterprise
A pragmatic rollout pattern we see working:
- Pilot on bounded work — dependency upgrades, test coverage gaps, migration scripts. Measure acceptance rate and rework.
- Write the CLAUDE.md first — encode conventions before expecting the agent to follow them.
- Wire MCP servers for the systems that matter — issue tracker, CI, docs — so the agent works in your workflow rather than beside it.
- Keep review gates — agents produce pull requests; humans merge them. Code review becomes more important, not less.
- Govern it like any AI system — inventory the deployment, assign accountability, document the risk assessment. If you operate in the EU, this maps directly onto your AI management system obligations.
On that last point: agentic coding tools are AI systems under your governance umbrella. Our ISO/IEC 42001 guide explains the management-system framework, and the free ISO 42001 AI Readiness Assessment gives you a baseline score in about ten minutes.
Frequently Asked Questions
Does Claude Code replace code review?
No — it shifts it. Agents generate the diff; reviewers verify intent, edge cases, and fit with the architecture. Teams that skip review accumulate subtle defects faster than they accumulate features.
What is the difference between Claude Code and a chat assistant?
A chat assistant returns text you apply yourself. Claude Code operates the loop end-to-end — reading files, running commands, executing tests — inside your environment, with permissions and an audit trail.
Is MCP only for Claude?
No. MCP is an open protocol now supported by most major AI tools and IDEs. An MCP server you build once works across agents, which is why it has become the standard integration layer.
How do we control what the agent can access?
Through the permission model (scoped tool allowlists), sandboxed execution, MCP servers that expose only the endpoints you choose, and hooks that enforce policy on every tool call. Treat agent credentials like any service account: least privilege, scoped, auditable.
