{} Claude Skills · ch.1 · what is a skill, really?
🛠 Chapter 1 · The anatomy of a Claude skill

What is a skill, really?

A skill is a markdown file (plus optional helpers) that teaches Claude how to do a specific thing well. Not memory, not a hook, not a tool — just a recipe Claude reads when triggered.

There's a whole vocabulary floating around — skills, hooks, memory, agents, tools, MCP. They each do something different. This chapter pins down what a skill actually is, when it's the right answer, and when something else fits better.

The whole story in one line: a skill is a markdown file Claude reads when triggered, so it can do a specific thing the same way every time. Everything else in this chapter is making that precise.

1Skills, in plain English

A skill is a markdown file that teaches Claude how to do a particular thing well. That's it.

It lives on disk at ~/.claude/skills/<name>/SKILL.md. When something triggers it, Claude reads the file and follows the instructions inside. Not a plugin. Not a hook. Not a tool. Just a recipe.

The simplest mental model: imagine you've explained how to do X to Claude five times in five different chats. You're tired of typing it. So you write it down once, name it, drop it in the skills folder — and now Claude has it forever. Every time you'd repeat that recipe, that's a skill candidate.

💡
One-off prompts are great for one-off jobs. Skills are for patterns — the same shape of request you keep making. If you've never wanted to repeat it, don't bother. If you've wanted to repeat it twice, you've probably wanted to repeat it twenty times.

2The description IS the trigger

This is the single most important sentence in this chapter:

Claude decides whether to auto-invoke a skill based on the description field alone.

Every skill starts with a YAML frontmatter block — the metadata bit between the two --- lines. Two fields matter:

The name has to match the folder name — it's how the skill is addressed. But the description is what Claude reads at session start to decide what each available skill is for. A good description is:

  • Specific about when to use it — "when the user provides a YouTube URL", not "for YouTube stuff".
  • Loaded with concrete trigger phrases — words the user is actually likely to say: "transcript", "subtitles", "captions".
  • Clear about boundaries — when NOT to use it. The claude-api skill literally includes a "SKIP:" clause for non-Anthropic SDKs.

Too vague ("helps with YouTube stuff") and the skill won't fire when the user expects it to. Too eager ("use whenever the user asks anything") and it fires for everything — becoming noise.

Interactive · trigger phrase tester Edit the description · see which prompts would match
keywords:
🎯
The body of the SKILL.md doesn't influence triggering at session start — Claude only sees the description. Save the deep detail for the body, where Claude reads it once the skill is actually active.

3The two ways skills get invoked

There are exactly two paths. Knowing both is enough.

Explicit — the user types the slash command

The user types /skill-name <args>. Direct, intentional, always works no matter how the description is written. This is the path that's never ambiguous — useful for skills you want to fire only when you ask.

Implicit — the description matches

The user says something natural like "can you grab the transcript of this video?" — and Claude scans the descriptions of all available skills, looking for a match. If one fits well, it auto-invokes. This is the magic path: a well-written skill feels like Claude just knows what to do.

A well-tuned skill is invoked the same way both ways. The trigger phrases in the description are exactly the words natural users will say. If you find yourself thinking "I always have to type the slash command for this skill" — your description needs work.

4What lives in a skill folder

SKILL.md is the front door. Everything else is up to you.

The conventional layout:

~/.claude/skills/<name>/
  SKILL.md              # required — the recipe
  README.md             # optional — narrative docs
  scripts/              # optional — shell/node helpers
  templates/            # optional — prompt templates, file stencils
  references/           # optional — extended docs SKILL.md links to

The cardinal rule: SKILL.md is concise. Claude reads it on every invocation, so weight matters. Heavyweight content — long examples, full prompt templates, deep reference docs — moves to files SKILL.md links to. Claude only follows those links (with the Read tool) when actually needed.

This is the same instinct that drives any good README: keep the top of the file short and skimmable. Put the depth where someone who needs it can find it.

Interactive · SKILL.md anatomy Hover the highlighted parts
hover any part Mouse over the highlighted regions above to see what each part of a SKILL.md does.
example 1 / 3 · roman-numerals

5Skills vs Memory vs Hooks vs Agents

Four different things often get confused. Pick the right one and your tool feels inevitable; pick the wrong one and you'll fight it forever.

PrimitiveWhat it isWhen to use
Skill A markdown recipe Claude reads when triggered The same kind of workflow comes up repeatedly and you want to encode the how
Memory Persistent files holding facts about user / project You want Claude to remember non-obvious things across sessions (preferences, context, decisions)
Hook Shell command in settings.json, fires on events Something must run automatically every time X happens (after commits, on file change)
Agent A sub-task Claude delegates A bounded job worth running in a separate context (research, parallel writes, focused builds)

The quick decision flowchart:

  • "Should it run automatically, without invocation?" → Hook.
  • "Should it remember facts across sessions?" → Memory.
  • "Is it a reusable workflow?" → Skill.
  • "Is it a one-off bounded job?" → Agent.

Try the picker below — it asks you the same four questions one at a time and shows what to reach for.

Interactive · primitive picker Yes / no your way to the answer
question 1 of 4

6A worked example: youtube-transcript

The youtube-transcript skill ships with the CLI, is tiny, and does one thing well — a perfect example of the form. Here's what it looks like under the hood.

  • Frontmatter: just name and description. The description names the trigger phrases — "transcript", "subtitles", "captions" — and the URL format hint.
  • Body: usage commands, supported URL formats, output conventions ("CRITICAL: YOU MUST NEVER MODIFY THE RETURNED TRANSCRIPT").
  • Supporting files: a scripts/get_transcript.py that the body references.

Total file size: about 50 lines. Total job: extract a YouTube transcript in one consistent shape, every time. No more, no less.

🛠
Notice what's NOT there: no general-purpose YouTube logic, no fallback for non-YouTube videos, no caching layer. One thing, done well. Two skills doing one thing each beat one skill doing two things every single time.

7Two SKILL.md styles: minimal & structured

Skills come in two broad shapes. The minimal one fits on a phone screen. The structured one references supporting files. Both are valid — pick the shape that fits how often you'll touch the skill and how big the recipe really needs to be.

Two skill styles. The minimal one fits on a phone screen; the structured one is what book-builder itself looks like under the hood. Both are valid — pick the shape that fits how often you'll touch the skill.

8Common pitfalls (you'll hit one of these)

  • Over-broad triggers — "use this whenever the user wants something" fires too often. Noise.
  • Under-specific triggers — missing the natural keywords users actually say. Get specific.
  • Hardcoded user paths/Users/daffy/... baked in makes the skill non-portable. Fine for personal skills, brittle for shared ones.
  • SKILL.md doing too much — if your SKILL.md is 500 lines, move detail into templates/ or references/ and have SKILL.md link to them.
  • Mixing concerns — a skill should do one thing well. "If A do X, but if B do Y" — that's two skills.
  • Forgetting about portability — if you ever want to share the skill, avoid baking in single-user assumptions.
⚠️
When NOT to write a skill: for a one-off prompt, just write the prompt. For automation that runs without your asking, use a hook. For something to remember, use memory. For domain knowledge that should always be in context, a CLAUDE.md is usually lighter than a whole skill. Skills are great — but only for patterns.