Academy Artifact

Open Standard Skills Pattern Interactive

Agent Skills

Package your methods, standards, and tools into folders that agents can load on demand. Skills turn general assistants into reliable specialists without repeated prompting.

Start the tour Build a skill

Portable by design Built for real work Progressive disclosure

Why Skills

Stop re-teaching. Start re-using.

Skills let you package the way you work once. When a task matches a skill name or description, the agent loads that folder automatically and applies your standards up front.

Repeating yourself

Explain your standards every time a similar task comes up.
Paste examples, templates, and references over and over.
Fix format drift when the output misses your preferred structure.
Lose context when you move between chats or projects.

Where Skills fit in your workflow

Skills

Repeatable procedures

Reusable instructions, tools, and references that load automatically when a task matches.

Projects

Accumulating context

Long-running workspaces where knowledge builds over time for a specific effort.

Custom instructions

Global preferences

Stable rules about how the model should behave everywhere, all the time.

One-off prompts

Exploration and experiments

Best when you are trying something new and do not need repeatable structure yet.

Anatomy

A skill is a folder with memory.

At its simplest, a skill is a directory with a single SKILL.md file. The metadata loads at startup, and the body routes the agent to deeper knowledge only when needed.

Skill structure

- create-new-skill.md
- audit-skill.md
- core-principles.md
- use-xml-tags.md
- report.md
- analyze_form.py

SKILL.md is always loaded

The agent pre-loads the name and description from SKILL.md. When the skill is relevant, it reads the full file. That is your chance to set principles, routing, and required tags.

---
name: pdf-forms
description: Extracts and fills PDF forms. Use when working with PDFs or form fields.
---

<objective>...</objective>
<quick_start>...</quick_start>
<success_criteria>...</success_criteria>

Keep SKILL.md lean and route deeper details to other files for progressive disclosure.

workflows/ are procedures

Use workflows for step-by-step tasks. The router in SKILL.md points here, so the agent follows a clear sequence without guessing.

<process>
1. Identify the gap
2. Draft the skill
3. Test on real tasks
4. Iterate based on failures
</process>

references/ are knowledge

Store domain knowledge, patterns, and examples here. The agent reads these only when relevant, which keeps the context window efficient.

<common_patterns>
Provide examples when format matters.
Use consistent terminology.
Keep instructions direct.
</common_patterns>

templates/ are outputs

Templates define the output structure the agent should copy and fill. They are perfect for reports, specs, and repeatable formats.

# Report Title

## Executive summary
## Key findings
## Recommendations

scripts/ are executable tools

Scripts give agents deterministic power. The code runs without entering the context window, so results are fast and repeatable.

python scripts/analyze_form.py input.pdf
python scripts/fill_form.py input.pdf fields.json output.pdf

Progressive Disclosure

Load only what is needed.

Skills scale because the agent only reads the files required for the current task. The rest stays out of the context window until it is useful.

At startup, the agent only knows the name and description of each skill. This metadata is enough to decide if a skill should be loaded.

"Building a skill is like onboarding a new hire."

You capture the steps, standards, and examples that make your work repeatable. That is how knowledge travels through teams and across time.

Skill in Action

The PDF skill: from reading to doing.

Claude already understands PDFs, but cannot manipulate them directly. A skill adds scripts so the agent can analyze and fill forms without loading the code into context.

Why scripts matter

Deterministic tools beat token guessing. The agent can run a script, get a clean result, and move on with confidence.

Code runs outside the context window.
Repeatable outputs for the same inputs.

Step 1

Skill triggers

User asks to fill a PDF form. The agent loads SKILL.md.

Step 2

Read forms.md

Pull instructions for field mapping and validation.

Step 3

Run analyze_form.py

Extract fields and coordinates without manual inspection.

Step 4

Fill and verify

Populate fields and verify output before delivery.

Ready. Click "Run the flow" to simulate the skill.

python scripts/analyze_form.py contract.pdf > fields.json
python scripts/fill_form.py contract.pdf fields.json signed.pdf

Authoring Principles

Write skills like you write playbooks.

The best skills are precise, structured, and tested in real work. Start small, be direct, and let progressive disclosure do the heavy lifting.

SKILL.md is non-negotiable

Put essential principles here because it always loads.

Use XML tags only

Required tags: objective, quick_start, success_criteria.

Progressive disclosure

Move deep detail into references and workflows.

Evaluate and iterate

Test on real tasks, then refine based on failures.

Be clear and direct

Say exactly what the agent should do. If format matters, show an example. Replace vague phrases with explicit rules.

Router pattern for complex skills

Use a small router in SKILL.md to send tasks to workflows and references. This keeps context lean while supporting multiple paths.

Security matters

Audit any skill you did not author. Inspect scripts, dependencies, and external calls before use.

<objective>What the skill does</objective>
<quick_start>Minimal example</quick_start>
<success_criteria>How to know it worked</success_criteria>

Authoring checklist

YAML frontmatter with name and description
Pure XML tags, no markdown headings
Required tags present and correct
References and workflows linked clearly
Tested on real tasks, not imagined ones
Only trusted skills installed

Build a Skill

Draft your first skill in minutes.

Start with a focused use case. The mini builder below generates a SKILL.md stub and a folder map you can refine into a working skill.

Mini skill builder

Anthropic engineering paper

Equipping agents for the real world with Agent Skills. A practical blueprint for why skills work and how they scale.

Open article

Claude support guide

How skills fit with projects, custom instructions, and everyday prompting.

Read the guide

Create agent skills reference

Practical templates, XML tag guidance, and testing workflows.

Open the repo

Trust note

Only install skills you have audited or that come from trusted sources. Skills can include executable scripts and external calls.