A skill costs 1.5 tokens, an MCP tool 15, and a subagent 1.72x the whole task
Every guide tells you to pick the cheapest mechanism that solves your problem. None of them says what any of them costs. Here are the four prices, measured, so the advice is actually usable.
The standard framing is good: skills are knowledge, MCP servers are actions, subagents are isolation, and you should pick the cheapest thing that does the job. The framing is also unusable, because none of the guides that repeat it will tell you what any of these costs.
Here are the numbers. Every one came off a real run and links to the measurement behind it.
The price list
| Mechanism | Cost to have it | Cost to use it | Charged again per round trip? |
|---|---|---|---|
| Skill | ~1.5 tokens each | body is free until invoked | no |
| MCP tool, deferred (default) | ~15 tokens each | ~304 when actually loaded | no |
| MCP tool, loaded upfront | ~304 tokens each | — | yes |
| CLAUDE.md | 106 tokens + 0.26/byte | — | yes |
| Subagent | 0 | 1.72x the whole task | no |
Those are not small differences. They span more than two orders of magnitude for things people treat as interchangeable design choices.
A skill is the cheapest way to give Claude a procedure
1,000 skills, 3.9MB on disk, cost 1,461 tokens. That is about 1.5 tokens each, roughly what a name costs, and it is a 2.5% increase on a session.
The body is free. A 200-byte skill body and a 28,000-byte one both cost +5 tokens at startup, because the body loads only when the skill is invoked. Description length does not matter either: forty skills with 1,500-character descriptions cost the same 80 tokens as forty with 90-character ones. Full measurement.
So the context argument against installing lots of skills does not survive contact with a measurement. The real cost of a large collection is a crowded listing and picking the wrong one.
An MCP tool costs 10x a skill, or 200x if you switch tool search off
A tool with a 798-byte definition costs about 15 tokens deferred and about 304 loaded upfront. At 200 tools that is +3,054 against +60,854, a 95% saving from deferral, which is the default. Full measurement.
Against a skill at 1.5 tokens, an MCP tool is roughly 10x a skill when deferred and 200x when loaded.
That is the actual design signal buried under “MCP servers are actions”. If the thing you want is a procedure, a checklist, or reference material that Claude reads, a skill is two orders of magnitude cheaper. MCP earns its price when you genuinely need to reach a live external system, and it is an expensive way to package what is really a document.
A subagent does not save you money, it moves 6% of your context
This is the one people get most wrong, because the advice sounds free.
Delegating a three-file read to a general-purpose subagent moved the parent context from 126,825 down to about 118,650. A real saving of 8,175 tokens, or 6.4%. It cost about 218,000 tokens against 126,825 inline, which is 1.72x.
You spend roughly 91,000 extra tokens to save 8,175 in the parent, so it pays back only if that leaner parent survives about 11 more round trips. Full measurement.
Subagents buy context isolation, not savings. Delegating a small task late in a session is strictly worse than doing it inline.
CLAUDE.md is the only one you pay for continuously
CLAUDE.md costs 106 tokens of fixed overhead plus 0.26 tokens per byte, and unlike everything else in this table it is in your context from the first token of every session, which means it is re-sent on every tool round trip for the rest of that session.
The comparison that matters: the same 28,000 bytes costs 7,379 tokens in CLAUDE.md and 4 tokens as a skill body. That is 1,845x.
CLAUDE.md is for what Claude must know every time. Everything else belongs in a skill. This single move is the largest configuration saving available, and it is not a trim, it is a relocation.
Choosing, with the prices attached
| If you need | Use | Because |
|---|---|---|
| Rules that apply to every task | CLAUDE.md, kept short | 0.26/byte, charged on every round trip |
| A procedure, playbook or reference doc | Skill | 1.5 tokens to have, free until used |
| To reach a live external system | MCP, tool search on | 15 tokens deferred, unavoidable and fair |
| To keep a long transcript out of your main context | Subagent, only if the session continues | 1.72x total, breaks even after ~11 round trips |
The heuristic everyone repeats, cheapest thing that works, is correct. It just needs the price list to be actionable, and the ordering is: skill, then deferred MCP tool, then CLAUDE.md by the byte, then subagent.
One caveat on the skill numbers
Skill descriptions demonstrably reach the model, because relevance matching works off them. My measurement says that text costs nothing. I do not know how both are true at once, and I did not guess: it may be delivered through a channel reported usage does not count, or resolved lazily. The cost is measured; the mechanism is not.
All figures on Claude Code 2.1.226 unless the linked measurement states otherwise, headless, usage from --output-format json, every delta paired against a baseline captured in the same batch and reproduced across at least two runs. The ranked version of the practical advice is on the guide page, and you can measure your own project.
Superseded 2026-08-14, on Claude Code 2.1.231. Two of the three headline prices moved. A skill costs about 39 tokens on a clean project and about 3.8 on a machine with its own configuration loaded, so 1.5 was measured in the cheap regime rather than being the price of a skill: the re-measurement and its control. A loaded MCP tool measures 652 tokens rather than 304, for a fixture verified byte-identical, with isolation excluded as the cause: the re-measured curve. Deferred MCP holds at about 16 tokens. The ordering the post is built on survives, and the gap between a skill and a loaded MCP tool is wider than it says, not narrower.