Course: Introduction to Agent Skills

Mirrors: Anthropic Academy — Introduction to Agent Skills · https://anthropic.skilljar.com/introduction-to-agent-skills Audience: Claude Code users and developers. · Time: ~60 min + project Prereqs: claude-code-101, comfort editing files in a repo. · Backing notes: agent-skills, claude-code-overview Project: p13-agent-skill

A Skill is a reusable capability you teach Claude once and it reaches for automatically — "make a PowerPoint", "fill this PDF form", "follow our release checklist". By the end you can author a SKILL.md, understand how progressive disclosure keeps it cheap, bundle scripts and resources, and tell Skills apart from slash commands and subagents.

Learning objectives

After this course you can:

Define what an Agent Skill is and what a SKILL.md contains.
Explain progressive disclosure and why it keeps many skills affordable.
Lay out a skill's folder structure with bundled scripts and reference files.
Write a description that makes Claude auto-trigger the skill at the right time (and not the wrong time).
Package and share a skill across projects, users, and plugins.
Distinguish Skills from slash commands, MCP prompts, and subagents.

Module 1 — What a Skill is

🎞 Frame 1 · A capability bundle, not just a prompt · ⏱ ~3 min

🎬 Scene — A folder opens: a SKILL.md, a scripts/ directory, a templates/ directory. Claude reaches into it to build a slide deck.

🧠 Concept — An Agent Skill is a directory packaging a reusable capability: a required SKILL.md (instructions + frontmatter) plus optional scripts and resource files Claude can use. It's more than a prompt — it can ship code and assets. (Deeper: agent-skills.)

🖼 On screen

pptx/
  SKILL.md        ← required: instructions + name/description frontmatter
  scripts/        ← optional helper scripts Claude can run
  templates/      ← optional reference files Claude can read

✅ Checkpoint — What single file is required in every skill, and what does it hold? (SKILL.md — instructions plus name/description frontmatter.)

🎞 Frame 2 · The SKILL.md frontmatter · ⏱ ~3 min

🎬 Scene — The top of SKILL.md shows two YAML fields: name and description.

🧠 Concept — A skill's frontmatter carries a name (its identifier) and a description (what it does and when to use it). The description is the load-bearing field — Claude reads it to decide whether the skill is relevant. Treat it like a tool description.

🖼 On screen

---
name: pptx
description: Use whenever a .pptx file is involved — creating, reading, or editing slide decks. Do NOT use for PDFs (see the pdf skill).
---

# Body: the actual instructions Claude follows once this skill is loaded.

⚠️ Gotcha — A vague description ("handles presentations") gets the skill ignored or mis-fired. Lead with concrete triggers and include negative triggers.

✅ Checkpoint — Which frontmatter field determines when Claude invokes the skill? (description.)

🎞 Frame 3 · When does Claude reach for a skill? · ⏱ ~2 min

🎬 Scene — The user says "turn these notes into a deck" and Claude silently loads the pptx skill, then gets to work.

🧠 Concept — Skills are auto-triggered by the model, not invoked by the user. On every turn Claude has the available skill names + descriptions in view; when a request matches a description, it loads and follows that skill.

✅ Checkpoint — Who decides a skill fires — the user or the model? (The model, by matching the description.)

Module 2 — Progressive disclosure

🎞 Frame 4 · Only the description is loaded — at first · ⏱ ~3 min

🎬 Scene — A shelf of dozens of skills; only their one-line descriptions are "lit up". One brightens fully when a request matches.

🧠 Concept — Progressive disclosure: at session start Claude sees only each skill's name + description. The full SKILL.md body (and any bundled files) loads into context only when the skill becomes relevant. Skills are lazy, so you can have many at almost no idle cost. (Deeper: agent-skills.)

🖼 On screen

Idle:        [ name + description ] × N skills   ← tiny context cost
Triggered:   load SKILL.md body  → maybe read templates/foo.md on demand

✅ Checkpoint — What part of a skill is in context before it's triggered? (Just its name and description.)

🎞 Frame 5 · Keep the body short, push details down · ⏱ ~3 min

🎬 Scene — A short SKILL.md that says "for the full field reference, read reference/fields.md" instead of inlining 40 pages.

🧠 Concept — Progressive disclosure has a second level: keep SKILL.md lean and reference deeper files Claude reads only if needed. This keeps even a triggered skill cheap and focused.

🖼 On screen

## Steps
1. Parse the deck outline.
2. For layout rules, read `reference/layouts.md`.
3. Run `scripts/build_pptx.py <outline.json>`.

✅ Checkpoint — Why reference a file instead of pasting its contents into SKILL.md? (So Claude loads it only when actually needed, saving context.)

🎞 Frame 6 · Why this scales to many skills · ⏱ ~2 min

🎬 Scene — A counter shows "50 skills installed, context cost: ~50 short descriptions."

🧠 Concept — Because idle cost is only the description, a user or org can install lots of skills without bloating every conversation. The model surfaces the right one on demand. This is the core advantage of skills over stuffing everything into a system prompt.

✅ Checkpoint — Why doesn't having 50 skills installed slow down an unrelated conversation?

Module 3 — Structure, scripts, and triggering

🎞 Frame 7 · Folder structure & bundled resources · ⏱ ~3 min

🎬 Scene — The skill folder expands: scripts/build.py, templates/base.pptx, reference/layouts.md.

🧠 Concept — Beyond SKILL.md, a skill can bundle scripts (Claude runs them), templates/resources (Claude reads or uses them), and reference docs. Refer to them by exact relative path from SKILL.md so Claude can find them. (Deeper: agent-skills.)

🖼 On screen

form-filler/
  SKILL.md
  scripts/fill_pdf.py        ← "Run scripts/fill_pdf.py <data.json> <form.pdf>"
  reference/field_map.md     ← "For field names, read reference/field_map.md"

✅ Checkpoint — How should SKILL.md point Claude at a bundled script? (By its exact relative path.)

🎞 Frame 8 · Writing a description that triggers right · ⏱ ~3 min

🎬 Scene — Two descriptions side by side; the precise one fires correctly, the vague one fires on the wrong request.

🧠 Concept — The description is the prompt that gets Claude to call the skill. Lead with concrete triggers ("Use when the user mentions a .pptx file"), add negative triggers ("Do NOT use for PDFs"), and test it against real requests — iterate like you would a tool description.

🖼 On screen

Bad	Good
"Handles presentations"	"Use whenever a `.pptx` is created/read/edited. Not for PDFs — see the pdf skill."

✅ Checkpoint — Name the two things a strong description includes besides what the skill does. (Concrete triggers and negative triggers.)

🎞 Frame 9 · Where skills live · ⏱ ~2 min

🎬 Scene — Three locations highlighted: a home directory, a repo, a plugin.

🧠 Concept — Skills resolve from ~/.claude/skills/ (user-global), <repo>/.claude/skills/ (project-shared, committed so the team gets them), or bundled in a plugin. Project skills travel with the codebase.

🖼 On screen

~/.claude/skills/<name>/SKILL.md       ← personal, every project
<repo>/.claude/skills/<name>/SKILL.md  ← shared with the team (committed)
plugin bundle                          ← distributed capability

✅ Checkpoint — Where do you put a skill so your whole team automatically gets it? (<repo>/.claude/skills/, committed.)

Module 4 — Packaging and comparisons

🎞 Frame 10 · Packaging & sharing · ⏱ ~3 min

🎬 Scene — A skill folder is zipped into a plugin and installed by a teammate.

🧠 Concept — To share, commit a project skill, drop one in ~/.claude/skills/, or bundle multiple skills into a plugin (the .plugin format). Enterprises can deploy skills via managed config. (Deeper: agent-skills, claude-code-overview.)

✅ Checkpoint — What format bundles multiple skills for distribution? (A plugin.)

🎞 Frame 11 · Skills vs slash commands vs subagents · ⏱ ~3 min

🎬 Scene — A three-column table snaps into place comparing who invokes what.

🧠 Concept — These get confused. The discriminators are who invokes and what gets included. (Deeper: agent-skills, subagents.)

🖼 On screen

	Slash command	Skill	Subagent
Invoked by	User typing `/x`	Model (auto-detected)	Model (delegating a task)
Idle context cost	None	Just the description	None
Can bundle files/scripts	No	Yes	N/A (it's an agent)
Best for	Quick reusable prompt	Reusable capability	Isolated focused task

⚠️ Gotcha — An MCP prompt is also user-invoked but server-provided — don't conflate it with a slash command or a skill.

✅ Checkpoint — A reusable "build a PowerPoint" capability with bundled scripts — skill, slash command, or subagent? (A skill.)

🎞 Frame 12 · You can author skills now · ⏱ ~1 min

🎬 Scene — Recap slide: SKILL.md + description, progressive disclosure, bundled files, auto-trigger, share via repo/plugin.

🧠 Concept — You can now turn any repeatable workflow into a skill Claude reaches for on its own. Next, learn to delegate whole tasks with introduction-to-subagents.

✅ Checkpoint — Without looking, state what loads at idle vs on trigger for a skill. (Idle: name + description. Trigger: the body, then referenced files on demand.)

🛠 Project

Complete p13-agent-skill — Author Your First Agent Skill. You'll build a real skill with a SKILL.md, a bundled script, and a reference file; write a description that triggers reliably; and verify Claude auto-invokes it (and ignores it on a non-matching request).

🧪 Self-check quiz

What is the one required file in a skill, and what does it contain?
Which frontmatter field decides when Claude uses a skill?
Define progressive disclosure for skills.
What is in context for a skill before it's triggered?
Where do you put a skill so a whole team gets it automatically?
Name two things a good skill description should include beyond "what it does".
Who invokes a skill vs a slash command?
Which is right for a reusable capability that ships scripts: skill, slash command, or subagent?

<details><summary>Answers</summary>

SKILL.md — instructions plus name/description frontmatter. 2. description. 3. Only name+description load until relevant; the body (and referenced files) load on demand. 4. Just its name and description. 5. <repo>/.claude/skills/ (committed). 6. Concrete triggers and negative triggers. 7. Skill = model auto-triggers; slash command = user types /x. 8. A skill.

</details>

🎓 Certificate criteria

You've "passed" Introduction to Agent Skills when you can:

Write a SKILL.md with a triggering description and a short body.
Explain progressive disclosure and the idle vs triggered context cost.
Bundle and reference a script/resource by relative path.
Distinguish skills from slash commands, MCP prompts, and subagents.
Complete p13-agent-skill and confirm correct auto-triggering.

Tick this course off in progress and record the date you earned Anthropic's official certificate.

🔗 Sources & deeper notes

Official course: https://anthropic.skilljar.com/introduction-to-agent-skills
Docs: https://docs.claude.com/en/docs/claude-code/skills
Vault notes: agent-skills, claude-code-overview, claude-code-slash-commands, subagents
Next course: introduction-to-subagents