Creating Your First Skill

In short

A skill is a folder with a file inside: the file is called SKILL.md.
The folder's name becomes the command you type to call it up.
In the project if it's about that work, among your personal stuff if you want it everywhere.
The fastest way to write it: have it write it for you.

The shape: a folder, a file

A skill is a folder with a text file inside called SKILL.md. The name you give the folder becomes the word you use to call it up: if the folder is called summary, you launch it by typing /summary.

Which gives you the first practical tip: name it the way you'd say it out loud. One word, short, whatever would come naturally — because that's the word you'll have to remember three months from now.

What's inside the file

Two parts. At the top, a two-line header: the name and the description. Below, the actual instructions, written the way you'd explain them to a person.

The description sounds like a bureaucratic detail. It isn't: it's the most important line in the file, and it gets a lesson all to itself, the next one. For now just keep in mind that it says when that procedure should be used.

Below that, the body: the steps in order, what to check, what the right result looks like. Everything you've learned about instructions still applies: concrete and checkable beats generic and ambitious.

Where to put it

Same logic as the instructions file, and you already know it by now:

In the project — inside the working folder. It applies there, and if you share the folder with others, it applies for them too.
Among your personal stuff — in Claude's personal folder. It applies in every project you open.

Practical rule: if the procedure is about that job, it goes in the project. If it's about how you work, it goes among your personal stuff.

The smart move: get it written for you

There's no prize for having written it by hand. The fastest way is to describe the procedure to Claude and ask it to turn it into a skill: it creates the folder, the file, the header, and puts the steps in order.

It's the reflex worth building in general, and it goes well beyond skills: before doing something tedious by hand, ask yourself whether it can do it instead. You bring the content — the actual steps, which only the person who does that job really knows — and it handles the form.

But then read it over. It's a procedure you'll use a hundred times: it's worth the two minutes it takes to check it.

Trying it right away

New skills are picked up immediately, with no need to close and reopen anything: you write it and you can already call it up. The only time you need to restart is if the skills folder didn't exist at all yet when you opened the session.

So testing it is instant: write the skill, run it, watch what it does. And if it doesn't do exactly what you wanted, open the file and fix the line that's wrong — which is the beauty of a procedure written in plain language instead of programmed.

What's next

Now you know how to make one. What's left is understanding why Claude sometimes uses it on its own at just the right moment and sometimes doesn't even consider it, even though it's right there. The answer is in a single line, and it's the next lesson.

Did you get it?

Two minutes, no grade. Trying to answer — even getting it wrong — cements the concepts far more than rereading. Not in the mood? Skip it: the lesson still counts as complete.

What determines the word you use to call up the skill?

You want a skill to apply across all your projects, not just this one. Where do you put it?

What's the fastest way to write a skill?

1
1. 1
2. 2
3. 3
2
1. 4
2. 5
3. 6
4. 7
3
1. 8
2. 9
3. 10
4. 11
5. 12
4
1. 13
2. 14
3. 15
4. 16
5. 17
6. 18
5
1. 19
2. 20
3. 21
4. 22
5. 23
6. 24
6
1. 25
2. 26
3. 27
4. 28
5. 29
6. 30
7
1. 31
2. 32
3. 33
4. 34
8
1. 35
2. 36
3. 37
4. 38
9
1. 39
2. 40
3. 41
10
1. 42
2. 43
3. 44
11
1. 45
2. 46