CLAUDE.md, Skills, Hooks, Subagents: The Hidden Token Cost of Customizing Claude Code

Seven Ways to Customize — Seven Cost Profiles

On June 20, 2026, Anthropic published a guide to the seven ways you can customize Claude Code: CLAUDE.md (root version always loaded, subdirectory versions loaded on demand), rules (scoped or unscoped by path), skills (invoked on demand, sharing a token budget), subagents (run in isolated context and return a final message), hooks (triggered by lifecycle events, bypassing compaction), output styles (injected into the system prompt, never compacted), and additional system prompts (a CLI flag, effective for a single run).

The guide is framed around behavior — when each loads, how it survives compaction. But every one of these mechanisms also has a cost profile, because anything that occupies the context window is something you pay input tokens for on every turn it's present. Understanding that is the difference between a lean setup and one that quietly inflates every request.

Always-Loaded Context Is Always-Paid Context

The root CLAUDE.md is loaded into every session. Output styles inject into the system prompt and are never compacted. These are the most powerful customization methods precisely because they're always present — and that's exactly why they're the most expensive if you let them bloat.

Think of it this way: a 2,000-token CLAUDE.md is 2,000 input tokens added to every single turn of every session. At Claude Opus 4.8's $5 per million input tokens, that's $0.01 per turn — sounds trivial, until you multiply by hundreds of turns a day across a team. A bloated always-loaded context is a small tax levied on every request you ever make. The fix isn't to avoid CLAUDE.md; it's to keep it tight — build commands, conventions, the things that genuinely apply everywhere — and push everything situational into on-demand mechanisms.

On-Demand Beats Always-On for Specialized Knowledge

Skills are invoked on demand and share a token budget. Path-scoped rules only load when you're working in the relevant part of the codebase. Subdirectory CLAUDE.md files load only when you enter them. This is the cost-efficient pattern: specialized knowledge that's present only when relevant.

A rule that only matters for your payments module shouldn't be in the root context consuming tokens while you work on the frontend. Scope it to the path, and you pay for it only when it applies. The same logic favors skills over stuffing every workflow into CLAUDE.md: a skill costs tokens when invoked, not on every unrelated turn.

Subagents: Isolation as a Cost Strategy

Subagents are the most interesting from a cost angle. They run in isolated context and return only a final message to the main conversation. That isolation is a budgeting tool: a subagent can read 100,000 tokens of code to answer a question, and your main context only pays for the summary it returns — not the whole exploration.

This is how you do expensive, context-heavy work without polluting (and paying for) your main session's context on every subsequent turn. The exploration cost is real, but it's contained and one-time, rather than dragging a giant context along for the rest of the conversation. For broad codebase investigation, delegating to a subagent is often the cheaper path precisely because the bulk of the tokens never enter your main window.

Hooks: Determinism Without Token Cost

Hooks are triggered by lifecycle events and bypass compaction. Crucially, a hook that runs a linter or a formatter is doing deterministic work outside the model — no tokens consumed for the action itself. Using a hook to enforce something mechanical (run tests, format on save) is strictly cheaper than asking the model to remember to do it, because you're moving the work off the token-metered path entirely.

A Cost-Aware Customization Playbook

Keep always-loaded context minimal. Root CLAUDE.md and output styles should hold only what genuinely applies everywhere. Every token here is paid on every turn.

Push specialized knowledge to on-demand mechanisms. Path-scoped rules, subdirectory CLAUDE.md files, and skills cost tokens only when relevant. Use them for anything that doesn't apply to the whole project.

Use subagents for heavy exploration. Contain large, context-hungry reads in an isolated agent so your main session pays only for the summary.

Move mechanical work to hooks. Anything deterministic — linting, formatting, running tests — belongs in a hook, not in a prompt the model pays to process.

Customization is what makes Claude Code productive, and none of this is an argument against using it. It's an argument for using the right mechanism: always-on for the universal, on-demand for the specialized, isolation for the heavy. To see how context size and model choice translate into a monthly figure, run your numbers through our cost calculator.