00 Introduction
This course covers how Agent Skills work, best practices for creating them, and how to build skills across different use-cases — from marketing automation to code review to multi-agent research pipelines.
By the end, you'll be able to:
01 What are Skills?
A skill lives on the filesystem as a directory with a mandatory SKILL.md file
and optional supporting directories for scripts, references, and assets.
SKILL.md — the entry point
Every skill begins with a SKILL.md file containing a YAML frontmatter block
with a name and description, followed by the main instructions
in markdown. The instructions can reference additional files in references/
or scripts in scripts/.
Naming conventions
The folder name should match the name field in the frontmatter.
Use lowercase letters separated by dashes (e.g. analyzing-marketing-campaign),
and avoid reserved keywords like claude, anthropic, or chatgpt.
How to use a skill?
To use a skill, an agent needs two basic tools: filesystem access (to read and write files) and a bash tool (to execute code). These let the agent execute whatever a skill requires. From there, skills can be combined with MCP servers and sub-agents to build powerful agentic workflows.
For example, an agent can pull data via MCP and then rely on a skill to determine what to do with that data — how to compute metrics, apply rules, and format outputs. It can also delegate tasks to sub-agents with isolated context, which can themselves use skills for specialised knowledge.
02 When to Use a Skill?
Skills are the right tool when you have any of these situations:
In short: if you're repeatedly explaining the same workflow or bundling the same reference files every session, package it as a skill once and stop paying that tax on every conversation.
Uploading a skill to Claude
Package the skill folder into a .zip file and upload it via
Capabilities → Add → upload zip file in Claude. Skills are also applicable
in other coding environments like Codex, Gemini CLI, and more — they're an open standard.
03 How Skills Work
Skills are an open standard — they're transferrable across any skill-compatible agent. Build a skill once and deploy it across multiple agent products.
Progressive Disclosure
This is the core design principle behind skills. The idea is to only load data when it's actually needed — avoiding unnecessary pollution of the context window.
Skills solve this through three loading tiers:
name and description from the YAML frontmatter.
These live in the agent's context window so it knows what skills are available and how to trigger them.
SKILL.md
instruction body is loaded — the step-by-step workflow, formulas, output format, etc.
This architecture means you can have many skills registered at once without bloating the context window — only the skill that's actually needed gets fully loaded.
04 Why Use Agent Skills?
When building purpose-specific agents — finance, research, coding, marketing — the underlying
foundation is actually a general-purpose agent: a simple scaffolding of bash and
filesystem tools. What these agents lack is the underlying context
and domain expertise to do the job reliably.
Beyond domain knowledge, skills also provide repeatable workflows. In a non-deterministic environment where model outputs can vary, skills give the agent articulate, step-by-step instructions for a task — making agent behaviour more predictable and measurable.
Three use-case categories
- Brand guidelines and templates
- Legal review processes
- Data analysis methodologies
- Weekly marketing campaign review
- Customer call prep workflow
- Quarterly business review
- Creating presentations
- Generating Excel / PDF reports
- Building MCP servers
Without skills — the cost
Every session without a skill means you have to:
Skills are portable
Agent skills are now an open standard, adopted by a growing number of agent products. The same skill works in Claude Code, agents built with the Claude Agent SDK, Gemini CLI, Codex, and more.
Skills are composable
You can chain multiple skills to build complex, predictable pipelines. Here's an example marketing pipeline:
05 Skills vs Tools, MCP & Sub-agents
Skills vs MCP
Connects your agent to external systems and data — Google Drive, databases, APIs, and more.
MCP is the pipe that brings data in.
Teaches your agent what to do with that data — how to analyse it, which rules to apply, how to format the output.
Skills are the expertise that acts on the data.
Skills vs Tools
Tool definitions always live in the model's context window. Skills are progressively loaded only when needed — this distinction is key. Skills can also include tools on demand, triggered selectively through progressive disclosure rather than always occupying context.
Skills vs Sub-agents
A main agent can spawn sub-agents that work independently and report back. Sub-agents have isolated context with fine-grained permissions and can run tasks in parallel. You can specify which skills each sub-agent has access to, letting the main agent act as orchestrator while sub-agents handle specialised work.
skills + tools
skills + tools
skills + tools
Summary comparison
| Feature | Skills | Prompts | Sub-agents | MCP |
|---|---|---|---|---|
| What it provides | Procedural knowledge | Moment-to-moment instructions | Task delegation | Tool connectivity |
| Persistence | Across conversations | Single conversation | Across sessions | Continuous connection |
| Contains | Instructions + code + assets | Natural language | Full agent logic | Tool definitions |
| When it loads | Dynamically, as needed | Each turn | When invoked | Always available |
| Best for | Specialised expertise | Quick requests | Specialised tasks | Data access |
06 Pre-built Skills
Anthropic ships a set of pre-built document skills you can use out of the box. These encode hard-won best practices for creating each document type — available libraries, rendering quirks, output conventions.
There's also a skill creator skill — a meta-skill that guides the agent through the creation process and best practices for writing new skills. It's one of the most useful tools in the kit for bootstrapping domain-specific skills quickly.
Hands-on exercises in the course
07 Key Takeaways
Agent skills are genuinely one of the most practical primitives I've seen in agentic AI. The core insight is simple: don't explain, package. If you're repeating yourself to an agent — whether that's workflow instructions, domain rules, or reference documents — wrap it in a skill and let the agent discover it automatically.
The progressive disclosure model is elegant. By keeping only the skill's name and description in context at all times, you can register many skills without bloating the context window. The full instructions only load when they're actually needed — a smart tradeoff between discoverability and efficiency.
And the open-standard angle matters: a skill written today for Claude Code works tomorrow in any other skill-compatible agent environment. The investment compounds.