Claude Code: AI coding directly in your terminal — an in-depth guide

Imagine typing in your terminal: "Add a contact form endpoint with Zod validation and rate limiting" — and watching the code get written, tested, and committed automatically. That's what Claude Code does.

But it's far more than a smart autocomplete. Claude Code is a complete AI developer tool with a permission system, memory, hooks, and a skills system that makes it an effective part of your daily workflow.

The part most write-ups skip is where the guardrails actually are. Agent Teams — the most advertised feature — is experimental and switched off unless you turn it on. The sandbox is opt-in. And a set of tools called "enterprise-grade security" means something quite specific that is easy to overread. This article states each of those with the date it was checked, because the honest version is more useful to you than the promotional one.

What is Claude Code?

Claude Code is an agentic coding tool from Anthropic that lives in your terminal. It's not just autocomplete — it's an AI agent that can:

• Read and understand your codebase (up to 1 million tokens of context, depending on the model)
• Write new code based on natural language
• Run tests, catch bugs, and fix them automatically
• Handle git workflows (commit, branch, PR, rebase)
• Navigate and edit files across projects
• Plan larger tasks with a step-by-step approach

It works with any IDE and has native extensions for VS Code, Cursor, Windsurf, and JetBrains. The models behind it change; the one most of my older notes point at is Claude Opus 4.6, which is now a legacy model — the current lineup is Opus 5.5, Sonnet 5.5, and Haiku 4.5.

How it's different

Most AI coding tools suggest code line by line. Claude Code understands your project and can perform complex, multi-file operations. It's the difference between a spell checker and a co-author.

Agent Teams: multiple agents in parallel — and still experimental

Agent Teams let you coordinate several Claude Code instances working together: one session acts as the team lead, teammates each work in their own context window, and they message each other directly rather than reporting back through the lead.

Two corrections to what you read elsewhere, both from the Agent Teams documentation:

• Teammates do not each get a tmux pane by default. The default display mode is in-process: teammates run inside your main terminal and you select them from the agent panel. Split panes are a separate mode that requires tmux or iTerm2 (and don't work in VS Code's integrated terminal, Windows Terminal, or Ghostty).
• Teammates do not sit inside the lead's context. The lead's conversation history does not carry over. Each teammate loads the same project context a regular session does — CLAUDE.md, MCP servers, skills — plus the spawn prompt. Write the spawn prompt accordingly.

What it costs, honestly

Anthropic documents that agent teams "use approximately 7x more tokens than standard sessions when teammates run in plan mode", because every teammate is a separate Claude instance with its own context window. Their guidance is to keep teams small, use Sonnet for teammates, and shut them down when the work is done — an idle teammate keeps burning tokens until it exits or the session ends.

Their own sizing advice: start with 3-5 teammates for most workflows, and 3 if you have 15 independent tasks. Team size scales token cost linearly, and coordination overhead grows with it.

Known limitations, from the documentation

No session resumption with in-process teammates (/resume and /rewind do not restore them), task status can lag and block dependent tasks, shutdown can be slow, one team per session, no nested teams, and the lead is fixed for the life of the session.

The docs are also explicit about when not to use them: sequential tasks, same-file edits, and work with many dependencies are better served by a single session or by subagents.

Key features in depth

CLAUDE.md — project configuration

Each project directory can have a CLAUDE.md file that gives Claude Code context about the project:

# CLAUDE.md
## Commands
- `pnpm dev` — Start development server
- `pnpm build` — Production build
 
## Architecture
- Next.js 16 with App Router
- Tailwind CSS v4
 
## Conventions
- Use `cn()` from `src/lib/utils.ts` for className merging
- Translations in `src/messages/{da,en}.json`

CLAUDE.md is loaded into context at session start, so every line of it is paid for on every request in that session. Anthropic's cost documentation gives a concrete target: keep CLAUDE.md under 200 lines and keep only essentials in it, moving specialised workflows into skills instead.

Skills system

You can define custom skills in the .claude/skills/ directory — reusable prompts and workflows:

# .claude/skills/wp-plugin.md
When creating a WordPress plugin:
1. Follow WordPress Coding Standards
2. Use WordPress hooks (actions/filters)
3. Add PHPDoc comments
4. Include uninstall.php

Skills load on demand, only when invoked — unlike CLAUDE.md, they don't sit in every session's context. That difference is the reason to move a detailed workflow out of CLAUDE.md and into a skill.

Hooks — workflow automation

Hooks let you run shell commands automatically in response to Claude Code's actions:

• Pre-commit hooks: Run linting and formatting before a commit
• Post-edit hooks: Run tests automatically after file editing
• Custom hooks: Trigger deployment, notifications, or other workflows

Hooks are also the documented way to cut token cost: the example in Anthropic's cost docs is a PreToolUse hook that greps a large log file for ERROR and returns only the matching lines, turning tens of thousands of tokens into hundreds.

Memory and context

Claude Code has two levels of memory:

1. Project level (CLAUDE.md): shared knowledge about the project, loaded at session start
2. Auto-memory: notes Claude saves about your preferences and recurring errors as it sees them over time

The practical rule from the documentation is about context size rather than sentiment: cost scales with how much context you send, so /clear between unrelated tasks, keep CLAUDE.md lean, and delegate verbose operations (test runs, fetched docs, log files) to subagents so the bulk of the output stays in their context instead of yours.

Extended thinking

Before Claude Code writes code, it uses extended thinking — an internal reasoning process that plans the approach. Anthropic documents the following, all of which are more useful than a made-up latency figure:

• Extended thinking is enabled by default, because it measurably improves performance on complex planning and reasoning tasks
• Thinking tokens are billed as output tokens, and the default budget can run to tens of thousands of tokens per request depending on the model
• For simpler work you can lower the effort level with /effort, or disable thinking in /config
• You cannot turn thinking off on Opus 5.5, Sonnet 5.5, or the Fable models — they always use it

The security model: read this part properly

Permission system

Claude Code has a granular permission system:

1. Automatically allowed: reading files, searching code, analysing projects
2. Requires approval: writing files, running shell commands, creating commits
3. Never allowed: destructive actions aren't performed without explicit instruction

You see a prompt showing what Claude Code wants to do, and you approve or deny each action. In auto mode a classifier reviews actions instead of prompting every time — and in that mode, a relayed approval from another agent is treated as untrusted input, not as your consent.

The sandbox is opt-in — turn it on deliberately

With the sandbox enabled, the actual boundaries are:

• Write access is scoped: the working directory, a per-user temp directory, and any directories you add with --add-dir / /add-dir / permissions.additionalDirectories
• Read access is not scoped by default — the default is read access to the entire computer, except certain denied directories. That default still allows reading credential files such as ~/.aws/credentials and ~/.ssh/. Use sandbox.credentials (or denyRead) to close that.
• No network domains are pre-allowed. The first time a command needs a host, Claude Code prompts; approving once allows it for the session, "Yes, and don't ask again" writes a WebFetch(domain:...) rule to your local settings.
• Protected paths stay unwritable even inside your working directory: .claude settings, .claude/skills, .claude/agents, .claude/commands, .claude/hooks, .mcp.json, .bashrc/.zshrc, .gitconfig, and hooks/config inside .git. A command that could edit those could grant itself permissions.
• Credentials can be denied or masked. mode: "deny" blocks reads and unsets the variable; mode: "mask" shows commands a sentinel and lets the sandbox proxy substitute the real value on egress to hosts you allow, so the command authenticates without ever holding the real secret.

Platform support: the sandbox runs on macOS, Linux and WSL2. Native Windows is not supported — on Windows you run Claude Code inside a WSL2 distribution, and WSL1 gives you no sandboxing at all. On Linux and WSL2 you need bubblewrap and socat; on Ubuntu 24.04+ the default AppArmor policy also has to be adjusted before bwrap can create the user namespaces it needs.

What Anthropic does and does not do with your code

This is the claim most worth getting right, because "doesn't train on your code" is only true under specific conditions:

• Claude Code sends your code to Anthropic's API to generate responses.
• On the Free, Pro and Max plans, model training is opt-out.
• On Team and Enterprise, it is "None by default".
• Enterprise plans add custom data retention controls, audit logs, and a Compliance API for observability.

The residual cost is not the training question but the operating question: the sandbox does not by default prevent reading your .env file or your SSH keys, and permissions are not a substitute for a human reading the diff.

Pricing

Claude Code is included in all paid plans, and this is the part that decides your bill: "It shares the same usage limits as the rest of your plan, so your work in the terminal and your chats draw from one pool." You cannot keep a chatty month separate from a heavy Claude Code month.

Every plan resets usage on a rolling five-hour session window, and paid plans add weekly limits on top. Anthropic is explicit that there is no fixed message count — what you get depends on conversation length, model choice, and which features you use. If you hit a limit you can wait for the reset, move up a plan, or turn on usage credits and keep working at standard API rates.

For most freelancers and small teams, Pro is the sensible starting point. Max makes sense if Claude Code is your primary tool all day. For a business running this across several people, the number that actually matters is not the seat price — it is this, from Anthropic's own cost documentation:

Across enterprise deployments, the average cost is around $13 per developer per active day and $150-250 per developer per month, with costs remaining below $30 per active day for 90% of users.

The lever on that number is model choice, not seat tier: Sonnet handles most coding tasks well and costs less than Opus, so reserve Opus for complex architectural decisions.

Practical examples for WordPress developers

Understanding an unfamiliar codebase

claude "Explain the architecture of this WordPress theme.
What custom post types are there? Which hooks are used?
Where are the main template files?"

Claude Code goes through the entire theme and provides a structured overview — invaluable when you're taking over a project from another developer.

Building a custom plugin

claude "Build a WordPress plugin that adds a custom REST API
endpoint /wp-json/my-plugin/v1/latest-posts that returns
the latest 5 blog posts with title, excerpt, and featured image URL.
Add caching with transients (1 hour) and rate limiting."

Debugging WooCommerce

claude "My WooCommerce checkout fails with a 500 error after
updating to WooCommerce 9.x. Analyze the error log in
wp-content/debug.log and find the cause."

Claude Code reads the log file, identifies the error, and suggests (or implements) the fix. On a project this size, the sandbox's read scope is worth checking first — a wp-content/debug.log can contain more than you want in a prompt.

Git workflow

claude "Review all my changes, write a descriptive commit
message following conventional commits, and create a PR
with a summary of the changes."

Performance optimization

claude "Analyze this WordPress theme for performance issues.
Check for N+1 queries, missing caching, unnecessary plugin calls,
and large images without lazy loading."

Limitations and gotchas

Claude Code is powerful, but not perfect:

• Agent Teams are experimental and off unless you enable them
• The sandbox is off unless you enable it, and if it can't start you get a warning rather than a block
• Read scope is wide by default — the sandbox does not protect your credentials unless you tell it to
• Context limit: while 1M tokens is enormous, very large monorepos can still exceed the limit
• Hallucinations: Claude Code can suggest code that looks correct but contains subtle errors — always review the code
• Cost is a function of context: a long session sends its full history every request, and thinking tokens are billed as output
• Platform: macOS and Linux have the sandbox; native Windows is not supported, WSL2 is required for it
• WordPress-specific knowledge: Claude Code is a generalist — it knows WordPress well, but it will not know your site's custom post types, your host's quirks, or which plugin version you actually run

Tips for effective use

1. Turn the sandbox on deliberately — /sandbox, then set failIfUnavailable if you want a hard failure
2. Deny or mask your credentials — ~/.aws/credentials, ~/.ssh, GITHUB_TOKEN and friends are readable by default
3. Write a lean CLAUDE.md — under 200 lines, essentials only, workflows in skills
4. Be specific in your prompts — "add validation" is bad, "add Zod validation of email and phone number with Danish formats" is good
5. Use plan mode for complex tasks — let Claude Code plan before it codes
6. Always review the code — AI-generated code should be reviewed like all other code
7. Delegate the noisy work — tests, logs, docs go to subagents so they don't fill your context

Claude Code vs. alternatives

When to choose what?

• Claude Code: you want an agent that can act on the whole project — run the tests, open the PR, follow the repo's own conventions
• GitHub Copilot: you want quick inline suggestions without leaving your IDE
• Cursor: you want AI integrated into your entire editor experience

I'm deliberately not putting a price in this table. Each vendor changes its own pricing, and a number I copied here would be wrong within a month without adding anything — check claude.com/pricing, github.com/features/copilot/plans and cursor.com/pricing for current prices. I also don't rank these tools on security. That would be a comparison of claims, not of behaviour, and the security section above is the part worth your attention.

Conclusion

Claude Code is not just another AI coding tool — it is an AI co-developer that understands context, plans, and acts. What changed since the early write-ups is the shape of the trade-off: the tool is more capable, and the decisions about what it may touch are more of yours to make.

It also does this with a security model that is real and documented — granular permissions, a permission-aware sandbox you can enforce, protected paths, credential masking, and enterprise retention controls. The catch is that each of those is something you turn on or configure. A sandbox that silently falls back to unsandboxed execution is not a security boundary; it's a warning in a log.

For WordPress developers working with complex themes, plugins, and WooCommerce customisations, it can save hours every week. The gain is quality as much as speed: Claude Code catches bugs, suggests better architecture, and follows the conventions you wrote down — as long as you are the one checking the result.

What this means if you don't have a developer

Most people reading this are not choosing a coding tool. They are running a business and finding out that the thing they depend on — the site, the hosting, the integrations — now has an opinion about which model it runs on.

Here is the part that matters, and it is not the model: picking the tool is the easy half. Every one of these models writes plausible code that is wrong in ways only a careful review catches. The hard half is deciding what the AI is allowed to touch, who reviews the output, what happens when a plugin update breaks an integration it generated, and what the fallback is when the dependency is down on the morning a campaign goes live.

That is the part that does not scale by adding a better tool. It is ownership of a production system — and note that the security model above only protects you if someone configures it.

If that is the problem you are actually facing, that is the work I do as a technical partner — you get someone accountable for the whole stack, not a licence key. See what technical partnership costs (from 2,500 DKK/month for drift, 15,000 for full partnership), or tell me what you are running into and I will tell you whether it is worth fixing.

Sources

Everything version-specific in this article was checked against these primary sources on 29 September 2026:

• Anthropic — Plans and pricing — plan prices, seat tiers, what each plan includes, the shared usage pool, rolling five-hour window, weekly limits, usage credits, model-training defaults, context windows
• Anthropic — Claude Code: agent teams — experimental status, the enable variable, display modes, token cost, team sizing, limitations
• Anthropic — Claude Code: manage costs — enterprise cost averages, the CLAUDE.md under-200-lines guidance, thinking-token billing, effort levels, hooks and skills for reducing context
• Anthropic — Claude Code: sandboxed Bash — opt-in status, read and write scope, network prompts, protected paths, credential deny and mask, platform support, the Linux dependency setup

What I removed, and why: a widely repeated demonstration claim — sixteen parallel agents writing a C compiler in Rust with a stated line count, duration and test-pass rate — because I could not locate it in a primary source I could read. I removed a "30–60 seconds" figure for task duration, a "CodeWP is more specialised" comparison, and a security comparison table ranking Claude Code against OpenClaw, none of which I could source; a security ranking of a third-party tool is a claim about behaviour I did not test. Nothing was replaced with different numbers of the same kind. I also removed the price row from the comparison table rather than quote prices I would have to keep re-checking.