"Performance" for skills isn't latency in the traditional sense. It's: does the skill produce reliable behavior; does it consume reasonable context; does it integrate without slowing the conversation?
This page covers the performance considerations.
When a skill is invoked, its content loads into Claude's context. Long skills consume more tokens.
For frequently-invoked skills, context cost compounds.
A 200-line SKILL.md is fine. A 2000-line one suggests refactoring.
Does Claude invoke the skill when expected?
Vague descriptions miss invocations. Specific descriptions match better.
Including the words users actually say in the description helps matching.
Explicit "don't invoke when X" prevents wrong invocations.
Skills that compose into workflows shouldn't slow workflows down.
Skill A and Skill B both do similar setup. The second invocation re-does work the first did.
Solution: smaller, more focused skills that don't overlap.
Skills that produce long preamble before doing anything useful waste tokens.
If a skill can resolve quickly (the user's question is simple), let it. Don't always go through full procedure for trivial cases.
Skills using tools (Bash, Read, etc.) generate tool calls that consume context.
If a skill needs to read 5 files, batch the reads in one message instead of sequential.
Multiple independent operations in parallel (one message, multiple tool calls).
A skill that explores extensively before doing the actual work consumes context heavily. Match investigation depth to need.
For details on X, see references/x.md (read only if needed)
Don't preload all references. Load conditionally.
For some skills, the output can be cached:
First invocation: full computation
Later invocations in same session: use cached result
Achievable through conversation memory rather than persistent caching.
Compare:
The objective of this skill is to comprehensively review the code that has been
written, applying a thoughtful and rigorous analysis to identify issues that
may exist in the implementation, with particular attention to...
vs:
Review code for: bugs, style, security, performance.
The second uses 90% fewer tokens; communicates the same thing.
Examples are often more compact than the equivalent description. "Like this:" + 5 lines beats "the convention is..." + 30 lines.
Symptoms:
Diagnosis:
Older versions of a skill may be more compact than newer ones (which accumulate features). Sometimes a refactor reduces context cost while maintaining capability.
Track skill size over time. Bloat is a signal.
When multiple skills load in one conversation, context fills.
For long workflows, consider:
For independent work, subagents allow parallel processing:
Spawn 3 subagents to investigate 3 different files
Each completes its own work
Main agent synthesizes results
Faster wall-clock; isolated context per subagent; results returned compactly.
For independent work, this is dramatically faster than sequential.
For skill design: