Skills vs MCP servers vs CLI: same budget, three different bills.

Most discussions of these three treat them as alternative products to install. They are not. They are three slots inside the same context window, and each one bills differently. A skill that never fires still costs you tokens every turn. An MCP server you barely use costs you 5 to 10 times more than the entire skill catalog, every turn. A CLI command costs nothing until you actually run it, then potentially a lot. This page walks the math on all three and gives a rule for picking.

1. The three cost shapes, side by side

The fundamental question is when the tokens land. There are two timings: ambient (every turn, whether you use the thing or not) and per-invocation (only when you call it). Each mechanism picks differently.

2. What an actual session looks like

A realistic Claude Code session for a mid-size project: 12 installed skills, 4 MCP servers (a database tool, GitHub, Linear, and a custom data-pipeline server), one global CLAUDE.md plus one project CLAUDE.md totalling 6,400 tokens. Before you type anything, your context already looks like this:

That subtotal (about 23K tokens) is what every turn ships before the model reads a single line of your code. The single biggest chunk is the MCP tool listings at 8,930 tokens. The 12 skills account for 1,540 tokens because the skill listing is capped by the skillListingBudgetFraction default of 0.01 (~2,000 tokens on a 200K context). MCP has no equivalent cap. The mechanism with the worst defaults is also the one most people install most of.

3. Why a single MCP tool costs more than ten skills

A skill listing entry is a name plus a one-sentence description. An MCP tool listing entry has to include every parameter, its type, its description, defaults, and which ones are required, so the model knows how to call it without a round trip. The schema is what makes MCP reliable, and also what makes it heavy.

Here is a realistic single tool from a GitHub MCP server. Count the words. Eight properties, each with a description, plus a top-level description that has to explain the contract:

That one tool definition is about 510 tokens. The same GitHub MCP server typically exposes 20 to 30 tools. Even at the median 450 tokens per tool, a single MCP server is carrying 9-13K tokens of ambient context cost. A typical skill description for the equivalent procedural advice ("use the gh CLI to open PRs with a body argument") is closer to 120 tokens.

This is not an argument against MCP. Structured I/O is genuinely better than parsing shell output for some tasks. It is an argument against treating MCP installs as free. Every server you add is a permanent tax on every turn of every session.

4. The same rubric scores all three

The token-cost math is one piece. The other piece is that the prose you write inside any of these mechanisms (the SKILL.md body, the MCP tool description, the rule lines in CLAUDE.md that direct Bash usage) all share the same failure modes: bloated lines, vague absolutes, missing-why prohibitions, cache-busting timestamps. ccmd's analyzer at src/lib/analyzer.ts:41 inspects only the first 300 characters of any paste to pick a label, then runs the same Karpathy-12 rubric and 7-finding pipeline against the body. Same scorer, three input shapes:

The findings (bloat, vague, aspirational, missing_why, cache_bust, duplicate, conflict) are language-agnostic. The 28-word bloat threshold at src/lib/analyzer.ts:150 applies to a tool description in an MCP server's metadata exactly the way it applies to a rule in CLAUDE.md. A 50-word tool description is 50 words the model has to read on every turn, and Anthropic's own field results show rule lines beyond 28 words start losing the second clause.

So the workflow is the same for all three: paste the body into ccmd.dev, read the findings, cut the lines flagged at high severity, re-paste. The chars/4 heuristic at src/lib/analyzer.ts:37 gives you the token count, the rubric gives you the structural gaps, and the findings give you the line-by-line cuts.

5. A decision rule that does not cost you a weekly limit

Three questions, in order. The first one usually answers it.

• Does Claude need to round-trip structured data? If yes (you want a typed result back, you want to chain calls, you need a stateful connection), MCP is the answer. The ambient cost is real, but the alternative is asking Claude to parse free-form shell output, which is unreliable past about three fields.
• Is the value mostly instruction the model needs to follow? If yes (a procedure, a style guide, a checklist, a code-review heuristic), it is a skill. Anthropic's skills system is specifically built for this shape: short description in the listing, full body only when matched.
• Is it a one-off shell command or script? Default to CLI. You give up ambient discoverability, but you get the cheapest possible mechanism. If the same command keeps showing up in your prompts week after week, that is the signal to promote it to a skill.

6. The 10-minute three-surface audit

7. What "cut" looks like

A typical mid-session project: 12 skills, 4 MCP servers, CLAUDE.md at 6,400 tokens. After one 10-minute audit:

Notice where the cut came from: roughly 4.7K tokens from MCP, 800 tokens from skills, and 2K from de-duplicating CLAUDE.md against the surviving skills. The pattern holds across most audits we run: MCP is the biggest single line, but the leveraged cuts come from de-duplicating prose between CLAUDE.md, skill bodies, and MCP tool descriptions. The same sentence is often in all three.