# What is a skill?

> Understand what a skill is, how an agent decides to load one, and how design-engineering routes every request through one entry point to the right note.

Module: Start from zero · Level: beginner · 6 min · https://school.agents.org.in/foundations/start/what-is-a-skill

Tell your agent "this dropdown feels slow" and, with the design-engineering skill installed, it does not guess. It opens a note about easing curves, reads that a menu should take about 200ms with a strong ease-out, and fixes it to that. Try a few requests and watch where each one lands:

*[Interactive demo: Every request goes in through one door and lands on the note that owns it.]*

## A folder of notes

A skill (A folder of written instructions an agent loads when a task matches, so it does the work the way you want instead of its default way) is a folder of plain text files written for an agent. At the top sits one file, `SKILL.md`, with a short description of when the skill applies. Beside it are the notes themselves.

That is all it is. No code to run, no magic. Just instructions, written down once, so the agent does the work the way an expert would instead of the way the average of the internet would.

```
design-engineering/
  SKILL.md              ← "load me when reviewing UI, picking easing…"
  references/
    motion/easing-curves.md
    motion/duration-table.md
    surface/contrast-and-color-scheme.md
    … about 200 more
```

## How the agent knows when to load it

Your agent reads only the short description of every installed skill at first. When your request matches one ("review this card", "why does this feel off"), it opens that skill's `SKILL.md`. From there it follows links to the one or two notes the job needs, and ignores the rest.

> **In plain words.** A skill is like a shelf of recipe cards. The agent reads the labels on the spines all the time, but only pulls out a card when you ask for that dish, and only reads the cards that recipe needs.

This matters because an agent can only hold so much in mind at once. Loading two notes about motion beats loading two hundred notes about everything.

## One skill, one door

design-engineering is a single skill with a single entry point. Whatever you want, you start the same way:

```bash
/design-engineering [verb] [target]
```

The slash command (A command you type into an agent starting with /, like /design-engineering. It runs a skill or a built-in action instead of being read as a normal message) `/design-engineering` opens the skill. What you type after it decides where it goes:

  **Step: A verb.** If the first word is a verb (The first word after /design-engineering, like review, polish or motion. It picks which procedure the skill follows) like `review`, `polish`, `motion` or `tells`, the agent opens that command and follows it step by step. `/design-engineering review src/PricingCard.tsx` reviews that file.

  **Step: A plain request.** If you just describe the problem, a router note reads it, decides which part of the craft owns it, and hands off. `/design-engineering why does this card feel flat`.

  **Step: Nothing at all.** On its own, `/design-engineering` shows a menu of verbs, leading with the two or three that fit what you are doing. It never runs one without asking.

## Thirteen clusters, two hundred notes

Behind the door, the notes are grouped into 13 clusters (A group of related notes in the design-engineering skill, one per part of the craft: motion, typography, layout and so on. There are 13), one per part of the craft: philosophy, motion, surface (color and depth), typography, layout, components, anti-patterns (the tells of AI-made UI), faux UI, SVG, sound, launch video, diagrams, and meta (how to review and direct).

Each note is a node (One note inside a skill: one idea with exact values and links to related notes, like "never scale from zero"): one idea, a few hundred words, with exact values and links to related nodes. "Never scale from zero" is a node. "The duration table" is a node. **The modules of this course follow the same clusters**, so what you learn here is exactly what your agent reads.

  **Agent without the skill (avoid):**

"The dropdown feels slow." It tries `transition: all 0.5s ease-in-out`, because that is common. Now it feels slower.

  **Agent with the skill (do this):**

Routes to `motion/easing-curves`. Sets `transform` and `opacity` only, 200ms, `cubic-bezier(0.23, 1, 0.32, 1)`, origin at the button. Tells you why.

*(Most of the time you will not type a verb at all. Describe the problem in plain words; the router is there for that.)*

## Your own taste, on top

Two files in the skill are meant for you to edit: `pov.md`, where you write opinions that override the skill's defaults, and `gotchas.md`, where you jot down mistakes the agent made so it never makes them again. You will not need them on day one. Just know the skill is a starting point you can make your own.

**See the router think (paste into your agent):**

```text
/design-engineering which: I want the settings page to feel less cramped. Tell me which cluster and which node own this, and why, before you change anything.
```

**Check yourself:** You type /design-engineering with nothing after it. What happens?

- [ ] It reviews every file in the project
- [x] It shows a menu of verbs, leading with the ones that fit, and waits
- [ ] It installs the skill again
- [ ] Nothing; you must always give a verb

*Why:* With no arguments and no request on the table, the skill shows its verb menu and waits for you to pick. It never auto-runs a verb.

## In the skill

- https://school.agents.org.in/skill/meta/skill-router.md
- https://school.agents.org.in/skill/meta/routing-table.md