Agent Skills Overview

By the Syncfusion DevTutorials team · Last updated October 22, 2026

What agent skills are and why developers use them: repeated prompts and lost context, the skill folder and SKILL.md, prompt vs skill, benefits and limits, and the coding tools that support skills.

Teach Your Agent a Task Once

An agent skill is a small folder of instructions. It teaches an AI coding agent how to do one task your way. In this lesson, you will learn what a skill is and why it helps.

Every chat with an agent starts fresh.

The agent does not remember what you told it yesterday.

So if your team has rules for a task, you have to type them again every time.

For example, your team may have rules for release notes:

• Group the changes by type.
• Call out anything that breaks old code.
• Use plain words.
• List anything you are not sure about.

On a busy day, you may forget one rule. Then the result is different from last time.

Simple lesson: a skill writes your rules down once. The agent reads them every time the task comes up.

A Real-World Example

You teach a new teammate how your team writes release notes.

A good teammate writes the rules down once and follows them every time.

An agent forgets the rules after each chat. A skill is the agent's written-down rules.

Click the button and open the Library tab.

• On the left: the files inside the skill folder. This skill has a style guide and a check script.
• Under the editor: a checker. It tells you if something in the skill is wrong.

Simple lesson: a skill is just a folder of text files. You can open it, read it and change it.

What You Will Learn

In this lesson, you will learn:

1. The problem skills solve.
2. What a skill is made of.
3. How a skill is different from a prompt.
4. What skills are good at, and where they fall short.
5. Which coding tools can use skills.

The Problem Skills Solve

Repeated Prompts

Most developers type the same requests again and again.

For example:

• "Write a commit message."
• "Review this diff."
• "What should I test here?"

Each request has rules that live only in your head.

When the rules live only in your head, three things can go wrong:

1. Rules get dropped. On a busy day, you forget some of them.
2. Results drift. Two people ask the same thing and get two different formats.
3. Nobody can review the rules. They are spread across old chats, not written in one place.

Watch what happens to the same request, without and with a skill:

Without the skill, the reply had none of the five headings. With the skill, it had all five.

Simple lesson: when the rules are written in a skill, every request gets all of them.

Lost Context

Context = everything the agent can see while it works.

Context includes:

• your message
• the files you have open
• earlier messages in the chat
• any instructions the agent was given

Context has a size limit. It is also not kept between chats.

You could paste every rule into every chat. But that makes each message long, slow and costly. Most of that text would have nothing to do with the task.

A skill fixes this. The agent loads its instructions only when the task needs them.

Simple lesson: a skill keeps the rules out of the way until they are needed.

What a Skill Is

The Skill Folder

Agent skill = a folder with the instructions an agent needs for one kind of task.

Skills use an open format. The same folder works in many coding tools.

The smallest skill is one folder with one file:

release-note-helper/
  SKILL.md

A bigger skill can hold helper files too:

release-note-helper/
  SKILL.md                    the main instructions (required)
  references/style-guide.md   extra detail, read only when needed
  scripts/check_notes.py      an exact check the agent can run
  templates/                  starting files to fill in
  examples/                   sample inputs and outputs

Simple lesson: start with one file. Add helper files only when you need them.

The SKILL.md File

SKILL.md has two parts.

Front matter = a few short lines at the top, between two --- marks.

• It holds at least a name and a description.
• The agent reads it for every skill when it starts.

Body = the instructions below the front matter.

• It says when to use the skill, the steps, the output format and the final checks.
• The agent reads it only when the skill is picked.

Important: the description is the most important line in the skill. The agent uses it to decide if the skill fits a request. So it must say what the skill does and when to use it.

Simple lesson: the front matter helps the agent choose. The body tells it what to do.

Which Skill Does the Agent Pick?

The agent compares your request with each skill's description.

The skill whose description matches best is picked. People say the skill fires.

Watch the agent choose a skill for one request:

Only one skill matched the words "release" and "changelog". So only that skill fired.

Click the button and open the Activation tab.

• Which skill fires for the request.
• Which words matched its description.
• How many tokens each loading step costs.

Simple lesson: a skill only fires if its description matches the words people really use.

Loading Only What Is Needed

A skill does not sit in every message. It loads in three steps:

1. Catalog. At start-up, the agent reads only the name and description of each skill.
2. SKILL.md. When a request matches, the agent reads that one skill in full.
3. Extra files. If a step says "follow the style guide", the agent opens that file only then.

Progressive disclosure = loading a little first, and more only when it is needed.

Watch the agent load one skill, step by step:

The agent read only a small part of the whole DevKit. That leaves room for your code.

Simple lesson: you can install many skills, because the agent reads them only when it needs them.

Skills Compared with Prompts

Prompt vs Skill

Prompt = a one-time message you type.

Skill = a saved set of steps the agent can use again and again.

The biggest difference is the output format. A skill can promise an exact shape, like "these five headings, in this order".

A fixed shape is easy to check. A script can check it for you.

Click the button and press Compare in the Run tab.

• Left reply: no skill. It fails the format check.
• Right reply: follows release-note-helper. It passes.
• Show the prompt button: it shows exactly what the skill added.

The review written without a skill says "Looks good overall!". It misses a SQL injection bug.

The pr-review skill tells the agent to look for bugs first, then security. Each problem gets a severity, a place in the code and a fix.

Simple lesson: a prompt is used once. A skill is saved, shared and used every time.

Skills and Other Agent Features

A skill is one of several ways to guide an agent. Each one has a different job.

A skill can use tools and scripts. For example, a bug triage skill can tell the agent to fetch the issue with a tool first. Chapter 6 covers these choices.

Simple lesson: use a skill for a repeated task. Use the other features for the jobs they do best.

Skill Benefits and Limits

Benefits

• Same result every time. The same request gives the same shape of answer, for everyone.
• Less typing. A short request like "review this" brings your full checklist.
• Small cost. A skill costs almost nothing until it is used.
• Easy to share. A skill is a folder of text. Commit it, and the whole team has it.
• Easy to review. The rules are written down, so the team can improve them.
• Works in many tools. The open format is not tied to one product.

Limits

• A skill only fires if its description matches. A vague description means the skill is ignored. Lesson 11 shows how to write good ones.
• Models can still drift. Final checks and scripts catch what the model misses.
• Not every task needs a skill. A question you ask once is just a prompt.
• Skills can be risky. A skill from the internet may hold harmful steps or scripts. Read it before you install it. Lesson 21 covers this.

Simple lesson: make a skill for work you repeat. Use a prompt for everything else.

Skills Across Your Stack

Skills are not only for writing text about code.

Every part of a developer's day has repeated work with team rules. An agent forgets those rules between chats.

All of these are in your DevKit. Each chapter of the course uses them.

Click the button and press Compare.

• Without a skill: the agent says the login form "looks clean".

• With ui-review: it finds four problems:

  • missing labels
  • a button you can't reach with the keyboard
  • faint text
  • an error shown only in red

Simple lesson: any task with team rules can become a skill.

Skill-Capable Tools

Agent skills started in one tool. Now many coding agents read the same SKILL.md folders.

Folder names differ a little between tools, and they change often. Lesson 10 shows the exact places for each tool.

There are two kinds of skill location:

• Project skill = a skill in the repository. Everyone on the team gets it.
• Personal skill = a skill in your home folder. It follows you across projects.

Example:

• Your team's release-note format belongs in the project.
• Your own habit of very short commit messages belongs in your personal folder.

Simple lesson: put team rules in the project. Put your own habits in your personal folder.

TL;DR

1. Agent skill = a folder with a SKILL.md that teaches an agent one repeated task.

2. SKILL.md has two parts:

   • Front matter = the name and description, read for every skill.
   • Body = the steps, output format and checks, read only when the skill fires.
3. Fires = the agent picks the skill because its description matches the request.
4. The description must say what the skill does and when to use it.

5. Skills load in three steps:

   • catalog
   • SKILL.md
   • extra files
6. Prompt = used once. Skill = saved, shared and used every time.
7. A skill guides the agent. Use final checks and scripts for exact rules.
8. A good first skill repeats often, has the same steps, and gives a result you can check.

Common Mistakes

Check Your Understanding

Exercises

These exercises help you practise reading and writing skills.

Press Check when you are ready. Use Show Hint if you get stuck.

What to Remember

• An agent skill is a folder with a SKILL.md that teaches an agent one repeated task.
• The front matter holds the name and description. The body holds the steps.
• The description decides when the skill fires.
• The agent reads the catalog first, then one skill, then extra files only if needed.
• A prompt is used once. A skill is saved, shared and used every time.
• A skill guides the agent. Final checks and scripts make sure.
• Good first skills repeat often and give a result you can check.

Next: Skill Anatomy. You will build your first skill from an empty folder.