How skills work
Skills use a progressive disclosure system that balances context efficiency with access to detailed information:Skills are always available
Claude sees the name and description of all installed skills in its context. This metadata (~100 words per skill) helps Claude decide when to load a skill.Example from the PDF skill:
Main instructions load on trigger
When a skill is relevant, Claude loads the SKILL.md body containing core instructions. This is typically under 500 lines and provides the main workflow guidance.The PDF skill’s main instructions cover:
- Quick reference for common tasks
- Python library usage (pypdf, pdfplumber, reportlab)
- Command-line tools (qpdf, pdftotext)
- Code examples for merging, splitting, extracting tables
Resources load as needed
For deeper detail, skills can bundle reference files that Claude reads only when needed:Claude reads these only when implementing specific functionality.
references/- Documentation loaded selectively (e.g., advanced API details)scripts/- Executable code that runs without loading into contextassets/- Files used in output (templates, icons, fonts)
Anatomy of a skill
Every skill follows this structure:Required: SKILL.md
The only required file isSKILL.md with YAML frontmatter:
name- Unique identifier (lowercase, hyphens for spaces)description- Complete description of what the skill does and when to use it (this is the primary triggering mechanism)license- Optional license informationcompatibility- Optional list of required tools or dependencies
Optional: Bundled resources
Skills can include additional files: Scripts (scripts/) - Executable code for deterministic tasks:
references/) - Detailed documentation:
assets/) - Files used in output:
- Templates (document templates, HTML scaffolds)
- Visual elements (logos, icons, fonts)
- Configuration files
Progressive disclosure in action
Here’s how the skill creator skill uses progressive disclosure: Level 1 - Metadata (always in context):- High-level workflow for creating skills
- Interview questions to capture intent
- How to write SKILL.md
- Testing and iteration process
- When to read reference files
references/schemas.md- JSON structures for evaluation filesagents/grader.md- How to evaluate test outputsagents/comparator.md- Blind A/B comparison processagents/analyzer.md- Benchmark analysis guidelines
Why progressive disclosure matters
This three-level system provides key benefits: Efficient context usage - Only load what’s needed for the current task:- Creating a simple skill? Just the main instructions
- Running complex evaluations? Load the grader and analyzer references
- Optimizing skill descriptions? Load the description optimizer docs
- Quick patterns? Check the main SKILL.md
- Detailed edge cases? Look in references/
- Reusable automation? Run scripts/
Skill triggering
Claude decides whether to use a skill based on the description field. Make descriptions specific:Claude tends to “undertrigger” skills - to not use them when they’d be useful. Make descriptions slightly “pushy” by listing multiple contexts where the skill applies.
Real-world example: MCP builder
The MCP builder skill shows progressive disclosure at scale: Main SKILL.md (~237 lines):- Four-phase workflow (research, implementation, review, evaluation)
- When to load each reference file
- High-level best practices
- Links to detailed guides
mcp_best_practices.md- Universal MCP guidelines (loaded during Phase 1)node_mcp_server.md- TypeScript patterns (loaded only if using TypeScript)python_mcp_server.md- Python patterns (loaded only if using Python)evaluation.md- Testing guidelines (loaded only during Phase 4)
- A Python developer never loads the TypeScript guide
- Implementation phase doesn’t load evaluation docs
- Context stays focused on the current phase
Key principles
When organizing large skills:- Main instructions should be workflows, not encyclopedias - Guide Claude through the process and tell it where to find details
- Reference files should be self-contained - Each reference should cover one topic completely so Claude can read just that file
- Scripts should be reusable - Write scripts that multiple skills could use, not one-off implementations
-
Group by variant, not by type - For skills supporting multiple frameworks:
Claude reads only the relevant cloud provider’s file.
Example: Building a brand guidelines skill
Here’s a simple but complete skill:- Has clear triggering in the description
- Provides actionable guidelines in ~30 lines
- Needs no bundled resources (colors and fonts are the only data)
- Can be used immediately
Next steps
Install skills
Set up skills in Claude Code, Claude.ai, or the API
Create your first skill
Use the template to build a custom skill