What Are Claude Skills? Anthropic’s Reusable AI Workflows Explained
Claude Skills package instructions, scripts and files into reusable workflows that load automatically when relevant.
Ask Claude to review your pull requests exactly the way your team does, every single time, without pasting the checklist into every chat. That repeated, fiddly work is the problem Claude Skills were built to solve: you package a process once as a skill, and Claude picks it up automatically whenever the task comes up.
Skills sit at the centre of how Claude does agentic work in 2026. They power the workflows inside AI coding assistants like Claude Code, they travel between the Claude app, the API and the Agent SDK, and Anthropic has published the format as an open standard. This guide explains what skills are, how they work, and how to build your own.
Claude Skills are reusable packages of instructions, scripts and reference files that teach Claude how to handle specific tasks. Each skill lives in a SKILL.md file with a short description; Claude reads the description and loads the full skill automatically when it becomes relevant. Anthropic launched the format as the open Agent Skills standard in October 2025, and skills work across Claude Code, the Claude API and the Agent SDK.
How Claude Skills Actually Work
A skill is not a prompt template. It is a folder of files, anchored by a SKILL.md document, that gives Claude everything it needs to perform one job well: the steps to follow, the scripts to run and the reference material to consult. When you ask Claude to do something related, it matches your request against the descriptions of your installed skills and loads the winner into its working memory.
The anatomy of a SKILL.md file
Every skill starts with YAML frontmatter at the top of its SKILL.md file. Two fields matter most: name, a short identifier like code-review, and description, a plain-language summary of what the skill does and when to use it. The description is the trigger. Claude decides relevance by reading descriptions, so a vague description means a skill that never fires.
Below the frontmatter comes the body: step-by-step instructions written for an AI reader. Good skill bodies are specific. They name the tools to use, the order of operations and the format the output should take. A skill can also bundle supporting files: shell scripts Claude can execute, document templates, API schemas or example inputs and outputs.
Progressive disclosure keeps context lean
One of the smartest design choices in the format is progressive disclosure. Claude always has access to every skill’s name and description, which costs very little context. The full body of a skill, plus its scripts and reference files, loads only when the skill is actually triggered. According to Anthropic’s documentation, this keeps routine conversations fast and cheap while letting complex skills carry detailed playbooks that would be wasteful to include every time.
This is what separates skills from a giant system prompt in every session. A 40-step deployment runbook can live inside a skill without taxing unrelated conversations, then appear the moment you ask to deploy.
Skills vs Prompts vs Custom Instructions vs MCP
New users often blur skills together with neighbouring features. The distinctions matter because each tool solves a different problem, and picking the wrong one produces fragile workflows.
| Mechanism | What it is | When it triggers | Best for |
|---|---|---|---|
| Claude Skills | Packaged workflows: instructions plus scripts and files | Automatically, when the description matches your task | Repeatable multi-step jobs like code review, report formatting, data migration |
| Custom instructions | Persistent preferences applied to every chat | Always on | Tone, formatting defaults, things you want in every response |
| Project knowledge | Reference documents attached to a project | Available on demand within that project | Background context: brand guides, specs, documentation |
| MCP servers | Live connections to external tools and data | When Claude needs a connected tool | Real-time data: databases, issue trackers, calendars, APIs |
Think of it this way: custom instructions shape how Claude talks, project knowledge tells it what is true about your work, MCP servers give it hands to touch live systems, and skills give it repeatable procedures to follow. The clarity you build writing better AI prompts transfers directly to writing good skills.
Where Skills Run in 2026
Skills are not confined to one product. Anthropic designed the Agent Skills format as an open standard, which means the same SKILL.md file can work in several places.
Claude Code
Claude Code is where most developers meet skills first. Developers add custom ones for team conventions: commit message formats, testing rituals, migration checklists. Skills can live at the personal level or the project level, checked into the repository so the whole team shares them. Team-shared skills have become one of the quietest productivity wins in agentic coding setups, because conventions stop being tribal knowledge and start being executable.
The Claude API and Agent SDK
For developers building on the API, skills let you ship domain expertise with your agent without hardcoding every procedure into your application. A support agent can carry a troubleshooting skill, a finance agent a reconciliation skill. Because the format is open, third-party frameworks have begun adopting compatible skill formats, which reduces lock-in.
Creating Your Own Skill in 7 Steps
Building a skill is mostly a writing exercise. You are documenting a process clearly enough that a capable colleague could follow it, because that colleague is Claude. Here is the process:
- Pick a repeatable task. Good candidates happen weekly, have clear steps and produce consistent output. Code reviews, release notes, data-cleaning routines and client report formatting all qualify.
- Write the trigger description first. Draft the one-paragraph description before anything else. It should say what the skill does and, crucially, when to use it. Test it by asking: would Claude pick this skill for the right request and ignore it for everything else?
- Document the steps in the SKILL.md body. Write numbered instructions naming the exact tools, the order of operations and what “done” looks like. Aim for the detail you would give a new hire.
- Add scripts and templates. If the workflow involves running commands or producing formatted output, include the script or template file in the skill folder and reference it from the instructions. This removes an entire class of inconsistency.
- Include examples. One or two worked examples of input and expected output improve reliability dramatically. Show the edge cases, not just the happy path.
- Test with real requests. Install the skill and use it on genuine tasks. Watch for misfires in both directions, and remember most fixes happen in the description, not the body.
- Share it. Commit project-level skills to your repository so teammates inherit them. Consider publishing generally useful skills to the directory or GitHub so others benefit.
A Practical Example: A Code Review Skill
Imagine a team that reviews pull requests against a consistent bar: security first, then correctness, then readability. Their code-review skill’s description reads something like: “Use when the user asks for a code review or feedback on a pull request, diff or code change. Applies the team’s review checklist covering security, correctness and style.”
The skill body walks through the checklist in order: security first, then correctness, then readability. It bundles the team’s severity labels and a comment template. The result is that every review follows the same standard, and the standard improves in one place when the team learns something new.
This pattern generalises. Anywhere a team repeats a judgement call, a skill can encode it. Onboarding documents become onboarding skills, and runbooks become executable. The knowledge stops living in wikis nobody reads and starts living in the workflow itself.
Limitations and Costs Worth Knowing
Skills are powerful but not magic. A skill cannot give Claude abilities it lacks; it organises abilities Claude already has. A skill that says “optimise this database query” still depends on the model’s actual database knowledge, though bundled reference files can close specific gaps.
Triggering is probabilistic. A poorly written description causes misfires in both directions: the skill loads for irrelevant tasks, wasting context, or stays dormant when needed. Treat the description as the most important paragraph you will write.
There is also a maintenance cost. Skills encode processes, and processes change. A skill that references a deprecated API becomes actively harmful, confidently applying outdated rules. Review skills the way you review documentation: on a schedule, with an owner.
Finally, skills consume context when loaded. Keep skill bodies tight, push long reference material into files that load only when referenced, and resist the urge to make every preference a skill. Truly universal preferences belong in custom instructions.
Frequently Asked Questions
Are Claude Skills free to use?
Creating and using skills costs nothing beyond your normal Claude usage. Skills are available on Claude’s paid plans and in Claude Code, and the Agent Skills format itself is an open standard you can implement anywhere. API usage follows standard token pricing, since loaded skill content counts toward context.
Do skills work in the Claude app or only in Claude Code?
Both. Skills originated with developers in Claude Code, but they also work in the Claude web and desktop apps and through the API and Agent SDK. The same SKILL.md format applies everywhere, which is the point of Anthropic making it an open standard.
How are Claude Skills different from custom GPTs?
Custom GPTs bundle instructions with a chatbot personality for sharing with end users, while Claude Skills are portable workflow packages focused on procedures, scripts and files. Skills emphasise automatic triggering by task relevance and reuse across Claude Code, the API and third-party tools rather than a shareable chat persona.
Can I share or sell the skills I build?
You can share skills freely: the format is plain files, so GitHub and the official skills directory both work for distribution. Teams commonly share project-level skills by committing them to repositories. Commercial marketplaces for skills are emerging, but check Anthropic’s current terms before selling, as policies evolve.
Do skills replace MCP servers?
No, they solve different problems and work best together. MCP servers connect Claude to live external tools and data, while skills encode how to perform tasks. A common pattern is a skill that tells Claude the procedure and an MCP server that provides the live data the procedure needs.
Conclusion
Claude Skills turn repeated expertise into reusable infrastructure. By packaging instructions, scripts and examples into a SKILL.md file that loads automatically when relevant, they remove the most tedious part of working with AI: explaining the same process twice. Start with one workflow you repeat weekly, write the description carefully, test it against real requests, and you will have the template for turning the rest of your team’s tribal knowledge into something executable. That single habit compounds into lasting leverage, and it is the real takeaway.
