← Back to Blog

I Removed 46 Unused Claude Code Skills. My Context Didn't Move.

November 18, 2026 · 5 min read

I cut my skill list from 81 to 35 and measured every session before and after. The opening context stayed at 54k tokens. Here's what was actually in it.

I had 81 skills installed in Claude Code. In the last 32 days I used 6 of them.

That looked like an easy win. Every skill's name and description is sent with every message, so 75 unused skills should be a fat, permanent tax on every turn. I removed them in two rounds and measured each session before and after.

The skill list shrank by 39%. My opening context went from about 54k tokens to about 54k tokens.

This article is about why, and what was really in those 54k.

Check your own first: run /context in a Claude Code session to see its current breakdown by category. For what your sessions cost over time, including every cold resume and cache rewrite, drop a session file into the free Session Viewer. It runs in your browser and uploads nothing. Session files are in ~/.claude/projects/<project>/.

Why the opening context matters at all

Before you type anything, Claude Code sends a fixed block: the system prompt, tool definitions, your skill list, CLAUDE.md, MCP server instructions and a few other things. Then your message goes on top.

That block is cached, so on a warm turn it's read at about a tenth of the normal input price. But it's read on every turn, and on every cold start (a new session, an expired cache, a resume) it's written to the cache again at full cache-write price. A bigger block means every one of those costs more.

My numbers come from my own logs: 81 sessions, 22,694 turns and 554 cold rewrites between October 16 and November 17. Claude Code writes everything I needed into the session .jsonl files.

Round 1: the SEO plugin

On November 1 I disabled an SEO plugin that added 26 skills. In 32 days I'd called it twice.

Skills Skill list size Average opening context
Before 81 29.3k chars 50.5k tokens
After 55 21.9k chars 51.1k tokens

The skill list dropped by a quarter. The opening context went up. Over the same weeks I'd connected more MCP servers and my CLAUDE.md and memory files had grown, and that more than covered the saving.

Round 2: everything else I never used

Of the 55 skills left, 51 had never been called. Fourteen were from one "token-saving" pack I installed and forgot about. I removed 20 of them, opened a new session, typed "hi" and measured it.

Skills Skill list size Opening context
Before (5 sessions that day) 55 21.9k chars 53.9k–55.6k tokens
After 35 18.0k chars 53.8k tokens

About 1k tokens saved. Those skills had short descriptions, so there wasn't much to remove. Over both rounds, the skill list went from about 7.3k tokens to 5.4k. Real, but small next to 54k.

So I stopped guessing and split the 54k into parts.

What's actually in 54k tokens

Each Claude Code session log records the parts of the opening context: the system prompt, every tool definition, the skill list, the CLAUDE.md files, MCP instructions, deferred MCP tool names and hook output. I measured each one by character count and scaled the counts to the measured total of 53,828 tokens.

Part ~Tokens Share My use in 32 days
Built-in tool: Artifact 16.4k 30.5% 3 calls
12 other built-in tools 14.5k 26.9% Bash 7,427 · Read 770 · … · 0 for two of them
Skill list (35 skills) 5.4k 10.1% 4 skills
CLAUDE.md + memory index 4.9k 9.1% —
MCP server instructions 2.9k 5.3% —
Vercel MCP: ~200 tool names 2.6k 4.8% 33 calls
Claude Code system prompt 2.0k 3.8% —
Hook output 1.9k 3.5% —
Git status, subagent list, other MCP names, environment ~4.1k ~7.6% —

Three things stand out.

1. Built-in tool definitions are 57% of the block. Skills, the thing everyone tells you to trim, are 10%. CLAUDE.md is 9%.

2. One tool is almost a third of it. The Artifact tool, which publishes HTML pages to claude.ai, has a definition of about 54,000 characters. I called it three times in a month. Add four more tools I called once or never (SendFeedback, ScheduleWakeup, ReportFindings, ListAgents) and rarely used tools are about 43% of every turn.

3. MCP cost has nothing to do with use. Vercel's server adds the names of about 200 tools to every session: 2.6k tokens for 33 calls in a month. Playwright, which I called 1,100 times, costs a few hundred.

To be fair to the numbers: some of these tools depend on your account and the features you have turned on, so your list won't look like mine. And the 3.5% of hook output is from L2Cache, my own app, which adds a project brief and recent clipboard items to each prompt. It goes on my list too.

What you can control, and what you can't

Grouped by who controls each part, my 54k splits like this:

[Pending: result of the permissions.deny test. Do not deploy until this is replaced.]

For the parts you do control, here's what moved the needle for me, in order:

  1. Disconnect MCP servers you aren't using this week. A server's cost is fixed per turn, whether you call it or not. claude mcp remove <name>, and add it back when you need it.
  2. Keep CLAUDE.md for rules the agent needs on every turn. Move reference material into a skill or a linked file the agent can read when it needs it.
  3. Check what your hooks add. UserPromptSubmit hooks inject text on every prompt, and they're easy to forget. Mine included.
  4. Then clean up skills. Worth doing, but expect hundreds of tokens per pack, not thousands.

How I measured it

Everything here came from the session logs Claude Code already writes. No proxy, no API key.

  1. For each session, take the first assistant response's usage: input_tokens + cache_creation_input_tokens + cache_read_input_tokens. That's the opening context.
  2. Before that response, the log records the parts as attachments: skill_listing, instructions (CLAUDE.md files), mcp_instructions_delta, deferred_tools_delta, hook_additional_context and a prompt_snapshot with the system prompt and tool definitions.
  3. Measure each part's character count. Divide the total by the summed characters (3.31 characters per token for me) to estimate each part's tokens.
  4. To see whether a part is used, count the tool calls (tool_use blocks) for each tool, MCP server and skill across your sessions.

These record formats aren't documented and may change between Claude Code versions. The shares are exact by character count; the per-part token figures are estimates.

What I'm doing with this

The breakdown was useful enough that I'm building it into L2Cache as an Initial Context view: the opening context for each project, how much of it you actually use, how it has grown over time, and which change caused each jump. The free Session Viewer already shows the other half of the cost: cold resumes and cache rewrites.

The lesson for me: I spent two clean-ups on the part I could see, and it was the smallest one. Measure before you trim.

See what fills your context

L2Cache shows what your Claude Code sessions cost, warns before a cold resume and hands off to a fresh session.

Download L2Cache for Mac