Fredrik SkauenAI Engineer
ENNO
Foundations

How Claude Skills work

By Fredrik Skauen5 min read

Skills are self-contained instruction sets that Claude pulls in when needed. What they are made of, how they load in stages, and why they turn Claude into a specialist in exactly your field.

To understand what Skills are, it helps to understand the problem they are trying to solve.

You often see that context management is closely tied to how effective the model is. That may change as models get smarter, but for now it holds: good context management gives better results.

Claude and other language models are “smart”, but they can't know everything about your particular field from the start. Do you need to generate API documentation? Set up a budget model? Make a presentation in your company's design profile? Do you have your own requirements for quality-checking text? What about a style guide for your documentation? Each task can require hundreds of lines of instructions, formatting rules and reference documents.

You could paste all of it into every single conversation. But context windows are limited and expensive. You could put it in a CLAUDE.md file, but it isn't necessarily relevant in every conversation.

This is where Skills come in. They are self-contained instruction sets that Claude pulls in when needed, and they let Claude suddenly know your field.

What is a Skill made of?

A Skill is simply a folder with a SKILL.md file at its root. The file is Markdown with YAML metadata at the top and instructions in the main body.

SKILL.md
---
name: meeting-notes
description: >
  Turns meeting notes into tidy
  minutes. Use when the user pastes in
  notes or asks for minutes.
---

# Meeting minutes generator

1. Identify participants, decisions
   and action items from the raw notes
2. Generate minutes using the template in
   references/referat-mal.md
3. Every action item must have a responsible
   person and a deadline
Much the same structure that is common for prompts.

A Skill can consist of more than just SKILL.md. You can include templates, scripts and reference files.

my-skill/
  • SKILL.mdrequired, the brain
  • references/documents loaded when needed
  • scripts/executable code
  • assets/templates, icons, fonts
A Skill is just a folder. Only SKILL.md is required.

How Skills are loaded and triggered

Skills load content in stages, so the context window doesn't fill up unnecessarily. Full instructions are only fetched when they are actually needed.

Layer 1 · always in context
Name and description (~100 words per Skill)
Claude sees these for every installed Skill, on every turn
↓ the user triggers the Skill
Layer 2 · loaded when triggered
The full SKILL.md (instructions, workflow, patterns)
Inserted into the conversation when the Skill is activated
↓ Claude reads as needed
Layer 3 · as needed
Bundled references, scripts and resources (unlimited size)
Only read or run when the Skill's instructions say so
Loading in stages keeps the context window lean, while the depth stays unlimited.

Activation happens in two ways: the user activates a Skill manually with a slash command, or Claude matches the request against the Skill descriptions and activates it automatically. The description field at the top of SKILL.md is the key. It is always available to Claude, so it can be checked against the user's request on every turn.

User message comes in
/commit
Explicit slash command
“write an explanation”
Matched against the description
SKILL.md is inserted into the context
Claude carries out the task with specialized instructions

When a Skill is activated, Claude pushes SKILL.md into the conversation as a system message. From there, Claude follows the instructions like any other prompt: read a reference file, run a script, generate a result.

A Skill can be anything from a simple formatting guide to a complete workflow with several steps.

Workflow in a Skill
# What the Skill tells Claude to do:

1. Read references/stilguide.md      # Fetch the design rules
2. Write rapport.html                # Generate the result
3. Run scripts/valider.py            # Check the quality

# Claude carries out the steps with its usual
# tools (Read, Write, Bash) –
# the Skill only says *what* to do.

The balance between detail and context

The art is balancing specificity against context length. Every word eats into the context window, but instructions that are too vague give poor results.

Rule of thumb: explain why, not just what. When Claude understands the reasoning behind an instruction, it can generalize to edge cases we don't foresee. Rigid “ALWAYS do X” rules are suboptimal; explaining the motivation behind X is almost always better.

The art is knowing what to specify and what you can leave to Claude:

High freedomLow freedom
Instructions in prose
“Write a report with these sections …”
Blog posts
Pseudocode patterns
“Use this template, adapt as needed”
Excel models
Exact scripts
“Run this Python file with these arguments”
Git operations
Match how specific the instructions are to how fragile the operation is.

Why Skills matter

Well-written Skills give you a different level of efficiency. Domain experts make the best Skill creators, because they can provide a level of detail that others can't. The result is a Claude that can become a specialist in exactly what you need, exactly when you need it, without having to load everything at once.

When Anthropic launched Cowork plugins, which are essentially Skills bundled with tool connections for specific industries, shares in legal and financial software fell by as much as 20% in a single day. Many believe there was a direct connection: the market was reacting to what it means when an AI can be specialized on demand. Whether that is true or not is for you to judge.

First published . Also available in Norwegian.

← All articles