Free course 2
Skills. Build and use.
In this course you will learn to
- take someone else's skill apart into five elements
- build your own skill for a repeating task and run it on 3–5 tasks
- check it with checkit and fixit and reach the verdict “clean”
Skill and prompt
A skill is a briefing, a prompt is a one-off request
Prompt
“Write an announcement for the book exchange on Saturday”
You write it again every time, and every time the announcement comes out different.
Skill
- Inputdate, place, theme, what to bring
- Procedurethe order of steps is written down once
- Outputan announcement in the same template
A prompt is work every time. A skill is an agreement written down once: you call it with one line.
Where skills live
The ladder: skill, workplace, agent, strict order of work (protocol)
| Step | What it is | Stop here if |
|---|---|---|
| Skill | Rules for one type of task | a set of your own skills covers your repeating tasks |
| Workplace | A place where the assistant sees your real files and folders (in course 3 this is “an assistant on your computer”) | you regularly work with files and projects |
| Agent | A chat you gave a role and a task that carries out the steps itself and picks the right skill | you often run a long process of many steps |
| Strict order of work | Written rules for a project: which documents to keep, how work is accepted, who decides what | the project runs through many chats |
Do not climb for the sake of the ladder: a skill you use every day beats an agent you do not trust.
A skill is an ordinary text file. Where you add it depends on your chat.
Anatomy of a skill
The five elements of a skill
- Role: who the model (the program that writes the chat's answers) is in this task and from whose point of view it looks.
- Context: what the model must know about your field: words, nuances. This is where your skill differs from someone else's.
- Procedure: the order of steps: first this, then that.
- Output template: the exact shape of the result: sections, order, length.
- Criteria: what counts as a good result and what to avoid.
One element missing, and the skill breaks at exactly that spot.
Practice
Take someone else's skill apart in five steps
- Open any ready-made skill (for example the gift on slide 10) and find the five elements.
- Read between the lines: the role may sit in the first sentence, the criteria in the examples.
- Run it on a piece of your own real data.
- Compare it with how you would have done it yourself.
- Mark the differences: those are the places to adapt the skill to yourself.
After taking a few skills apart you start to see the pattern, and building your own gets easier.
Choosing the task
Is the task ripe: five signs
- It repeats: you do it again and again.
- The shape is stable: input and result look alike every time.
- The request costs time: every time you spend long wording it.
- Stability matters, not “however it turns out”.
- You can explain to a beginner how to do it well.
One skill, one task. Three tasks, three skills one after another; split a long input into parts.
Before building
Five questions before you build
- Retell: state the task in your own words and write down the assumptions.
- Sample requests: two or three, in the words you yourself would use to ask for it.
- Name: short, in Latin letters, no spaces (for example book-exchange-announcement).
- Description: what the skill does and when to use it.
- Rules: the points of the procedure and criteria, no more than six, each with its reason.
Our skill: input is date, place, theme, what to bring; output is an announcement in one template.
What a skill file looks like
What is inside and how to name it
| Part | What is in it | Rule |
|---|---|---|
| File | One text file. Name it SKILL.md (“.md” is just the ending of the name) | nothing else is needed |
| Name | First line: the word name:, a space and a short name. These two words are typed exactly like this, in English; the ready skill on slides 10 and 11 already has them, you only replace the text after them. | Latin letters, no spaces, up to 64 characters |
| Description | Second line: the word description:, a space and one or two sentences: what the skill does and when to use it | up to 1024 characters (about ten lines); use the words you would say yourself |
The chat always sees a skill's name and description. It reads the rest of the text when the skill is needed: you called it by name, or the description fits the conversation.
Building
Six steps to build, a check at each
- One sentence: what comes in, what comes out. It does not fit: too early to build.
- The procedure in words, as you do it yourself: every step a concrete action.
- Two or three examples: a real input and the ideal result.
- Criteria: “must have this, must not have that”, checkable by eye.
- The file: all five elements in place.
- Test runs on real tasks: run, find the weak spot, edit.
A gift
Your first skill, step by step
A small working skill: it asks the design questions, assembles the five elements, proposes 3–5 test runs and names the typical mistakes
Download the small skillPractice
Build the “announcement by fields” skill
Copy the text, save it as a file named SKILL.md and add it to your chat: in the settings look for a section called “Skills”, “Projects” or similar (the name varies). If there is none, paste the text at the start of the chat. The first lines between the three dashes are the skill's “business card” (name and description); leave them as they are. Run it: give the four fields, date, place, theme, what to bring. The text stays in English; the skill answers in the language of your fields.
The skill file
---
name: book-exchange-announcement
description: "Writes an announcement for a book exchange event from fixed fields: date, place, theme, what to bring. Use when the user gives event details and asks for an announcement, a notice, a poster text or an invitation post for a book exchange."
---
# Book exchange announcement
Role: you are an organiser who writes short, friendly notices for neighbours and colleagues.
Context: a book exchange is a small event where people swap books they have read. The input is four fields: date, place, theme, what to bring.
Steps:
1. Check that all four fields are present. If one is missing, ask for it and stop.
2. Write the announcement in the template below.
3. Check it against the criteria and fix what fails.
Template (four lines):
Title: the theme, one line
Date and place: one line
What to bring: one line
Invitation: one closing line
Criteria: all four fields appear as given; no more than five lines; no exclamation marks; no invented facts; written in the language of the fields.
Testing
3–5 runs: predict, run, compare
- Predict: before the run, write down what the skill should do.
- Run it in a fresh chat that sees only the skill and your case.
- Compare: what you expected and what you got; quote the difference word for word.
- Find the cause: a fault in the file (something is missing) or a fault in the answer (the file is fine but the model did not follow it).
- Edit and repeat on tasks of different difficulty: simple, medium, hard, unusual.
One good run is not a test.
Testing
Does the skill get called on time: “should” and “should not”
| Request | Should the skill start? | Why |
|---|---|---|
| “Make an announcement: book exchange, Saturday, 12:00, the courtyard” | Yes | a direct request |
| “Write an invitation post for a book swap: here are the date and place” | Yes | the same job in other words |
| “Make a preparation plan for the book exchange” | No | a near miss: same theme, different job |
| “Write an advert for selling a bicycle” | No | the same word, a different job |
It starts on a “no” or stays silent on a “yes”: edit the description, because that is what calls the skill.
Checking a skill
“Be careful” does not work: ask for a checkable action
A wish
“Be careful and check your work”
It can be “done” in the head, and the model sincerely believes it was.
A checkable action
- List“Name three places where the skill can fail”
- Quote“Quote the line before you judge it”
- Stance“Find what is broken”, not “confirm it is fine”
The author does not sign off their own work: a model leans toward approving what it just made.
Checking a skill
Three depths of checking
| Depth | For | What you ask for |
|---|---|---|
| Small | A rough sketch, a few lines | Find wrong facts, gaps, drift from the task; say what cannot be verified |
| Medium | A real, finished file | Re-read it whole, find what was agreed but did not reach the text, mark “needs checking” |
| Full | A skill others will use, several files, or any doubt | A list of every claim, severity marks: SERIOUS (stops the work), MISSED (does not stop it, but something needed is absent), MINOR (cosmetic), logic errors, up to three rounds of checking |
In doubt, take the full one. A skill you will share gets an independent check with checkit.
A gift
checkit and fixit
checkit finds and does not fix; fixit fixes and does not confirm; a second audit says clean. These are two skill texts: add each one as on slide 11 and give it your own skill to check.
- checkit: hunts for defects, edits nothing, gives a verdict.
- fixit: repairs only what was found and never declares “clean”.
A worked example
A skill with two defects: the find, the fix, the verdict
01
First audit: “needs fix”
The course authors planted two errors in a practice skill in advance. checkit found both and several more: 1 mark SERIOUS (the template has no “what to bring” slot the steps rely on), 3 marks MISSED (one of them a description with no words a user would type), 4 marks MINOR.
02
The fix
fixit added the “what to bring” slot, rewrote the description with the words “announcement”, “invitation” and a sample request, and set rules for missing fields. It did not certify its own work.
03
The second audit's verdict
A separate checkit run: “clean” (meaning no SERIOUS or MISSED, only minor points left) — 0 SERIOUS, 0 MISSED, 4 MINOR. One thing only a live run shows: does the skill get called. That is your task: add it the same way as on slide 11 and ask “write an announcement for our book exchange on Saturday”.
The cycle: checkit finds, fixit fixes, a second audit confirms.
Before sharing
Pitfalls and a checklist before sharing
- A weak description: it lacks the words that get the skill called.
- More than six rules: the model starts to read them as advice.
- Rules in capitals with no reason: every rule carries its reason.
- A stray file (if your skill has several files): the main text never mentions it; mention it or delete the file.
- Old versions inside the skill: the log of edits lives elsewhere.
- A “fine” mark that does not say what was inspected.
Before sharing: five elements in place, no more than six rules, 3–5 runs passed, defects hunted by someone other than the author.
Looking after a skill
Versions and care: a skill lives while it is looked after
- Versions: a skill has a number (1.0, 1.1…); change it with every edit. Write the number as a line “Version: 1.0” right after the description, not inside it.
- A review on a schedule: remove what is outdated, add what failures showed.
- Cleaning: keep only what the skill needs to work; store old versions elsewhere.
- Sharing: after an independent audit and test runs.
The first version carries the minimum rules for your two or three cases; real failures add the rest.
Course summary
All your tools
05
Five elements
Role, context, procedure, output template, criteria.
Next, course 3: we run the event preparation with three levels of agents.
Your know-how is written down once, so the work goes the same way every time
We plan the demo version for November 2026 and the working version, with licences on sale, from 1 January 2027.
Go to the SANKORD site and subscribe there to the project’s updates.
Choose another course