Skills
Skills
A skill is a way of working, saved as a procedure. If knowledge is what the AI knows, a skill is how it should proceed. Write it once and you can reproduce the same approach in any thread, on any engine.
When to make one
- You can tell this kind of work will come up again
- You finally landed on a workflow after some trial and error
- You want colleagues to work the same way
Making one from a conversation
The easiest route is to build it from the thread where it actually worked.
Open that thread.
Choose πͺ Turn this thread into a skill from the thread menu β or Turn this into a skill from the composer's send options.
The AI reads the conversation, the equipment and the notes, and drafts a generalised procedure.
Review and save. Name, when to use it, the steps and the caveats are all editable at this point.
Generalise the project-specific values β company names, URLs, numbers β so it travels. And be concrete in the βwhen to use thisβ description: that's what lets the AI pick it up at the right moment.
Writing or editing one by hand
You can also start from scratch: οΌNew β Create a skill, described in the app as building a reusable procedure through conversation with the AI.
Existing skills open straight into the editor from the list. It is built like the agent-training screen: what the skill knows on the left, an assistant you talk to on the right. β on the list heading opens βSkill managementβ β the place for detecting skills on this Mac, importing, and creating new ones.
| Left: contents | What goes there |
|---|---|
| β Gotchas | Traps specific to this system β what reading the code won't tell you |
| β Verification | How to check the result yourself |
| π Steps | A numbered flow someone can reproduce |
| π Materials | References, scripts and templates |
Each heading shows how many entries it holds, and οΌ adds one on the spot. Description, tools, colour and the raw SKILL.md body live under β Settings β editing the body directly still works exactly as before.
Growing it by talking
The assistant on the right does three things: teach, test, hand it files.
| What you do | What happens |
|---|---|
| Teach it (βdo it this wayβ) | Suggestions appear as cards. Only what you keep goes in |
| Test it (βwhat would you do here?β) | It answers as the skill. Nothing changes |
| π Hand it a file | It reads the file and proposes what is worth keeping |
You decide entry by entry, exactly as with agents. One-off details are left behind β only what will still be true next time is proposed.
Writing β Gotchas and β Verification
Of everything a skill holds, these two decide its quality β which is why the editor puts them first.
| Field | What belongs there |
|---|---|
| β Gotchas | What goes wrong when you do it the obvious way |
| β Verification (how to check itself) | Steps for the AI to actually use what it produced and check the answer |
Both take one line at a time. Rather than trying to write them out in full up front, add a single line whenever you notice something.
Bundling documents, scripts and templates
The Resources tab on the skill screen holds files that travel with the skill. They're split into three kinds by purpose.
| Kind | What goes in it |
|---|---|
| References | Detailed material the AI reads when it needs it |
| Scripts | Code for the processing and checks you repeat |
| Assets | Templates for the deliverables |
Using one in a thread
Open the thread.
Equip the skill from π Knowledge, roles, connections.
Work as usual. When the situation matches, the AI follows the procedure you saved.
Equipped skills work on any engine β Claude, GPT, Kimi or Gemini.
Equipping a pile of skills muddles the instruction and costs you quality. Equip only the ones this thread will really use.
Recording a failure as a gotcha on the spot
When you spot a mistake in the AI's reply, drag-select that sentence and press β To gotchas. It goes straight into the gotchas of a skill connected to the thread.
Pointing the mistake out in the chat fixes that one reply and nothing beyond it. Kept as a gotcha on the skill, it stops the same mistake happening again.
Long procedures are read only when needed
When a skill's procedure is long, ChatGPT, Gemini, Kimi and code threads no longer load the whole text on every turn. They're handed the table of contents and the list of bundled files, and the AI goes and reads what it needs when it needs it. Measured, that cuts what's passed each time to around 7%, which leaves your other instructions far less likely to get buried. There's nothing to configure.
Bringing in existing skills
Skills already on this Mac for Claude Code (~/.claude/skills) and Codex (~/.codex/skills)
can be detected and imported. Once imported they work across every engine in WorkPilot.
Exporting and receiving
Skills can be exported as a file and handed to someone else, who imports it on their side.
Export
From the skill's screen. Before writing the file, it checks for anything that looks project-specific.Hand it over
Send the file by email or chat.Import
The recipient imports the file, and it joins their skill list.
A skill is a block of instructions telling an AI how to behave. Always read the steps before importing one from outside. On export you may see a warning that something identifying was found β generalise or remove it before sharing.
Where skills are stored
Under skills/ in your storage folder, one folder per skill.
The contents are Markdown, so you can open the folder and read them directly.
The full layout is in Settings and where data lives.
Auditing skills you no longer use
Skills record when and how often they were used. The list carries badges such as never used or {n} days ago, so the ones that never come up are obvious at a glance.
Open Audit unused skills below the skill list and you can Turn off anything from the usage table. While a skill is off it isn't passed to the AI, even in threads it's connected to. That isn't deletion β go without it for a while, delete it if you never miss it, and press Turn back on if you need it again.
The AI reads every skill's name and description to decide which one to use, and that judgement gets duller the more text there is. The audit screen shows a gauge for the Total description length against a recommended limit.
Testing whether it helps
π§ͺ Test effect on the skill screen runs the same instruction twice at once β with this skill and without it β and puts the two results side by side to compare.
If there's no difference, the skill is either unnecessary or has drifted towards general advice. In that case, adding information the AI can't know on its own to the gotchas is what makes it bite.
Keep improving them
A skill isn't finished when you save it. Feed back what you learn each time you use it β the point that tripped you up, the caveat worth stating β and you stop repeating the same mistake. Add them to the steps, or to the β Gotchas and β Verification fields.
Where to go next
- Knowledge β carry context rather than procedure
- AI team β give each role its own procedure
- Let it run on its own β put a settled procedure on a schedule