The usual objection to Skills is that they will eat the context window. It is a reasonable fear and it is wrong, because a Skill is not one blob of text. It loads in three stages, and two of them cost nothing until you need them.
Second in a series on Agent Skills.
Level 1 — metadata, always loaded
At startup, only the name and description of every installed Skill are placed in the system prompt. Roughly a hundred tokens each.
That is the number that matters for the objection. Thirty Skills installed is about three thousand tokens of permanent overhead — the price of a short email. You can install a lot of capability before this is worth optimising.
Level 2 — instructions, loaded on trigger
When your request matches a description, the agent reads SKILL.md off the filesystem and its body enters context. The guidance is to keep this under about five thousand tokens.
Note what just happened: the body was on disk the whole time, costing nothing, and became visible only at the moment it was relevant. This is the mechanism, and it has a name — progressive disclosure.
Level 3 — bundled files, loaded only if read
A Skill can ship as many extra files as you like: additional markdown, API references, database schemas, templates, examples, executable scripts. None of it costs anything until something reads it.
The consequence is unintuitive and useful: there is no real limit on how much you bundle. A Skill can carry a complete API reference and a dozen worked examples. If a task needs one of them, one loads. The rest stay on disk at zero cost.
What this looks like in a real Skill
Here are the measurements from a Skill sitting on my machine, one that recommends automation for a codebase:
- Description: 367 characters. This is all it costs while idle.
- SKILL.md body: about 11KB, read only when the topic comes up.
- Five reference files: about 32KB between them, each read only if that specific subject is needed.
So a Skill carrying roughly 43KB of material has a resting cost of a couple of sentences. Ask it about hooks and one 6KB file opens; the 8KB one about MCP servers stays shut.
The design rule this implies
Because Level 2 is paid in full every time the Skill fires, and Level 3 is paid only when read, the split matters:
- Put in SKILL.md what is needed every time the Skill runs: the workflow, the order of operations, the decisions.
- Push to a bundled file anything needed only sometimes: exhaustive field lists, error code tables, edge-case guidance, long examples.
A common mistake is a single 20,000-token SKILL.md that documents every branch. It works, and it charges the full price on every trigger. Splitting it costs nothing and often makes the instructions clearer, because the main file goes back to describing the happy path.
Where the model does the reading
Worth being precise about the mechanism, because it explains the cost model. There is no special loader. The agent reads these files with ordinary shell commands, the same way you would. When instructions mention another file, it reads that file too. When they mention a script, it runs it and sees only what the script printed.
That last clause is the most useful sentence in this series, and the next article is about it.
What to take away
Skills are cheap while idle, moderately priced when triggered, and free for anything they carry but do not read. Design against that gradient: a lean body, generous references, and the expensive detail one level further out than feels natural.
Next: why the description is the only part of a Skill most requests will ever see.