AI Agent Skills, Explained: What They Are and Why They Matter

You have probably heard someone say "I gave Claude a skill for that" and nodded along without a clear picture of what changed. This post fixes that. By the end you'll know what an AI agent skill is, what it's made of, why it matters more than it sounds, and how to write one that works.

Let me define two terms up front, because the rest depends on them. An LLM (large language model) is the AI that sits behind tools like ChatGPT and Claude: you type, it predicts a useful response. An AI agent is an LLM that can also take actions, like reading a file, running a script, or calling an API, instead of only talking back. Skills are how you teach that agent to do a specific job the way you want it done.

What is an AI agent skill? (and who invented it)

An AI agent skill is a packaged set of instructions you hand to a model so it can do a particular task well. In practice it's a folder. Inside that folder is one main file, SKILL.md, and optionally some supporting files: reference documents, scripts the model can run, templates it works from.

Think of the onboarding folder you'd give a sharp new hire. Not a lecture. A folder. It has the standard operating procedure for the task, the reference docs they'll need, and the templates they should fill in. You don't re-explain the job every morning. You point them at the folder, and they follow it. A skill is that folder, written for a model instead of a person.

That framing tells you what a skill is for: it captures the repeatable know-how for one job in a form the model can pick up and reuse, so you stop re-teaching the same thing. It's the same shift that lets teams package expertise on Askpert into something callable rather than something you re-explain in every meeting.

What is an AI skill, in one sentence?

An AI skill is the reusable folder a model reaches for when a task matches it, instead of you pasting the same instructions into the chat again. So if you have wondered what an AI skill is, or what AI skills are in day-to-day terms, that folder is the answer.

Contrast it with a one-off prompt. A prompt is what you type once, and then it's gone. Want the same result next week? You type it again, slightly differently, and get a slightly different answer. A skill is the opposite. You write the instructions once, save them in a folder, and the model uses that folder every time the job comes up. Same instructions, same reference files, same output. The prompt is the throwaway note. The skill is the saved procedure.

Who invented agent skills?

Anthropic introduced Agent Skills on October 16, 2025, and shipped them the same day across Claude.ai, Claude Code, the Claude API, and the Claude Agent SDK. Most people call them "Claude Skills," so you'll see both names for the same thing. If you want the primary source, Anthropic's engineering team wrote it up in Equipping agents for the real world with Agent Skills.

The format caught on fast because it's simple. A skill is just a folder with a markdown file in it, which any team can write without special tooling. Anthropic later published the skill format as an open standard, so the same folder can travel to surfaces beyond Anthropic's own products.

Why AI agent skills matter for LLMs

Here's the question you actually came for. Why is this a big deal, instead of a tidy way to store prompts?

Picture how most people work with a model today. You open a chat. You paste in your brand voice, your formatting rules, last quarter's numbers, the examples of "good" you keep in a doc. The model does the task. You close the tab. Tomorrow you do it all again. The model remembers none of it. Quality wobbles because the context you fed in was slightly different each time. Nothing carries forward, and nothing you built can be handed to a teammate. Every session starts from zero.

Skills change the economics of that. Once expertise lives in a folder, four things become true:

• Portable. The same skill runs across the Claude apps, Claude Code, and the Claude API or Agent SDK, so the know-how isn't trapped in one person's chat window.
• Reusable. Write it once, and the model applies it every time the task shows up, with no re-pasting and no drift between Monday and Friday.
• Versioned. A skill is a file, so you can improve it, track what changed, and roll back a bad edit the same way you would with any document under version control.
• Composable. Skills stack. An agent can hold a research skill, a formatting skill, and a compliance-check skill at once and combine them on a single task.

Add those up and a generic model becomes a dependable specialist. More than that, a whole team gets one source of truth for how a job is done. When your best analyst writes the revenue-report skill, everyone's model runs the analyst's method, not a fuzzy approximation of it. That's the shift: expertise stops being locked in one person's head and becomes something a team can hire on demand. We'll come back to how a skill differs from RAG and MCP in the FAQ, because that comparison trips up a lot of people.

What an AI agent skill is made of: the SKILL.md specification

The anatomy of the agent skills specification is plain. At the center is a single file called SKILL.md. It has two parts: a short block of metadata at the top, then the instructions below.

The metadata sits in what's called YAML frontmatter, a few labeled lines fenced between two --- markers. Two fields are required: a name and a description. That's the core of it. Some surfaces support extra fields (for example, restricting which tools the skill is allowed to use), so treat name and description as the fixed foundation and check your platform's docs for anything beyond them.

Around that one file you can bundle supporting material the model opens only when it needs it. Reference documents go in a references/ folder. Scripts the skill can run go in scripts/. Templates and files it produces from go in assets/. None of these are mandatory. A perfectly good skill can be a single SKILL.md with nothing else. The folders are there for when a job needs more than a page of instructions.

The SKILL.md specification: YAML frontmatter + instructions

Here's a minimal, real SKILL.md you can copy and adapt:

---
name: quarterly-revenue-report
description: Builds the quarterly revenue report from the raw sales CSV. Use when someone asks for the Q1/Q2/Q3/Q4 revenue summary or the numbers for the board deck.
---

# Quarterly revenue report

1. Read the sales export from `data/sales.csv`.
2. Group rows by product line and sum the `net_revenue` column.
3. Compare each line against last quarter using `references/prior-quarter.md`.
4. Write the summary in the wording and order shown in `references/tone.md`.
5. Flag any product line down more than 10% quarter over quarter.

Notice how ordinary that is. The frontmatter names the skill and describes when to use it. The body is a numbered procedure a competent person could follow. No magic syntax. The description field is doing quiet, heavy work here: it's the text the model reads to decide whether this skill fits the task in front of it. Keep it to a sentence or two, and make it specific about both what the skill does and when to reach for it.

Agent skills examples: a real folder layout

When a skill grows past a single file, it looks like this:

Each folder earns its place. references/ holds the thick material you don't want in the main file, like a style guide or last quarter's figures, so the model can pull it up only for the step that needs it. scripts/ holds code the skill runs when a task should be deterministic, like parsing a CSV the same way every time instead of eyeballing it. assets/ holds the templates and starting files the output is built from. Bundling beats stuffing everything into one giant prompt because the model reads only the piece the current step calls for, which keeps things fast and cheap. The next section explains why.

How to write the description (the make-or-break field)

If you take one authoring lesson from this post, make it this: the description is where a skill lives or dies. A model can only use a skill it decides is relevant, and it makes that decision by reading the description. A vague description means the skill sits unused while the model improvises. A sharp one means it fires at the right moment.

Compare these two.

Vague: description: Handles reports.

Specific: description: Builds the quarterly revenue report from the raw sales CSV. Use when someone asks for the Q1/Q2/Q3/Q4 revenue summary or the numbers for the board deck.

The second one names the task and, just as important, says when to use it, in the words a real user would type. "The numbers for the board deck" is in there because that's how someone might phrase the request. Write the description the way you'd describe the job to a colleague who has to decide, in one glance, whether this is the folder to open.

The idea that makes skills scale: progressive disclosure

Skills have one more property worth naming, because it is what lets a single model hold a big library of them without slowing down. A skill loads in layers, on demand. By default the model sees only each skill's name and description; it reads the full instructions only when a task matches; and it opens the heavy reference files only if a step actually needs them. That design is called progressive disclosure, and it is the single idea that makes skills practical at scale.

It is worth understanding on its own, so it gets a full walkthrough in the next post in this series: Progressive disclosure: how a skill loads only what it needs.

What we learned packaging skills into protected experts

We build on this every day at Askpert, where sellers package their know-how into rentable Experts. A few lessons from doing it at scale, offered plainly because they'll save you time whether or not you ever touch our platform.

First, the description field really is where reliability is won or lost, and that gets truer as you add skills. With one skill, sloppy wording is forgiving. With fifty skills competing to be the right match, a vague description is the difference between the model picking the correct expert and picking a near-miss. We spend real effort on that one line.

Second, progressive disclosure is what lets many skills coexist without wrecking the budget. When a buyer's request can touch any of dozens of Experts, you can't afford to load them all. Layered loading is the only reason a large library stays fast and affordable per call.

Third, and this is the part most explainers skip: a skill can carry runnable scripts and private documents, which means who can see those files is a real question. On Askpert, a skill's instructions, reference docs, and scripts run server-side and never appear in the response. The buyer gets the finished answer, not the SKILL.md, not the retrieved documents, not the code. The private assets stay sealed. That's a deliberate security invariant, and it's the gap most skill discussions leave open.

Fourth, skills turn expertise into something you can distribute and get paid for. A skill packages how a job is done well, and once it's packaged, buyers can rent by API or MCP without you being in the room. Want to see this in practice? Browse live experts to see packaged skills in action and notice that you receive results, never the underlying folder.

AI agent skills FAQ

From a skill to rentable expertise

A skill is just a clean way to write down how a job is done well, so a model can do it the same way every time. The natural next step is building your own, and there is more than one way to do it: we walk through each in How to create an AI agent skill. If you want yours to be something others can rent without ever seeing the folder, package your expertise in the Skill Studio and see how far one good folder can go.