# Skills: turning repeated work into reusable workflows
**The real win isn't a clever one-off prompt. It's writing a good prompt once, wrapping a little process around it, and saving it so you can run it again and again.**
## The problem
**You keep rebuilding the same job from scratch, every single week.**
The client deck you rebuild from a blank slide every time, wrestling the fonts and the brand colours, and it never quite matches last quarter's. The weekly update email. The first-pass reply to a complaint. The job ad from a rough brief.
Every time, you start cold:
- You half-remember what worked last time.
- You retype roughly the same prompt with slightly different words.
- You get a slightly different result, and you're never sure if this one is as good, or as on-brand, as the last.
That's the quiet tax. Not one big disaster, just twenty minutes of rebuilding, over and over, on work you've already figured out how to do well. The know-how lives only in your head, and your head is busy.
## The shift
**Write the job down once, in plain language, and never rebuild it again. That saved thing is a skill.**
A skill is a saved, reusable workflow. Think recipe card for a job you do often. At its simplest it's a prompt you keep. A good one is more: it also says when to use it, what to feed in, what to check, and what good output looks like. The prompt plus the process around it.
Why I care about this more than any single prompt trick comes down to one idea: the standard lives in the file, not in your head.
- **Consistency.** When the process is written down, the tenth output is as good as the first. You're not relying on your memory or your mood that day.
- **Compounding.** It costs twenty minutes once. It saves twenty minutes every time after. Do that across ten weekly jobs and you've quietly bought back hours, forever.
- **Handover.** A skill is shareable. Hand it to a colleague and they get your way of doing the job, not their best guess. I've handed someone a single file and watched them produce work that looked like mine on day one.
Here's what that looks like at full strength. I built a presentation-builder skill that holds my whole brand: the fonts, the colours, the slide layouts, the tone, the way I like a story to flow. I feed it a topic and a few rough notes, and it hands back a near-finished, on-brand deck I only need to tidy. A two-hour job became a ten-minute one, and the tenth deck is nearly as polished as the first. That is a skill properly earning its keep.
The format is deliberately boring: a plain text note. That plainness is the point. A plain note opens anywhere, lasts forever, and works across every AI tool you use.
The honest limit: build skills for work you genuinely repeat. For a true one-off, just write a prompt and move on. Don't turn skill-writing into its own procrastination.
## Watch me do it
**Don't just fix the agent's mistakes yourself. Tell it to write the fix down, so the same job goes far smoother next time.**
This is the move that saves you the most pain, and anyone can do it today. When an agent fumbles a task, the lazy instinct is to correct it and move on, then watch it fumble the same thing next week. Instead, I get it to write the lesson down.
My signal to build a skill: I've done the same kind of task three times. Not the first, not the second. Third time, the pattern's real and the laziness is justified.
The build is plain:
1. Open a new note (any plain text or notes app works).
2. Write down, in normal words, how I do the job when I do it well: what I start with, the steps, what I always check, the shape I want the answer in.
3. Paste in the best prompt I've been typing.
4. Run it on a real example, see where the output disappoints me, edit the file to fix it.
5. After two or three rounds it's sharp, and I stop fiddling.
**The bigger jobs.** A good skill file is a brief you write once. The steps and the standard are already set, so even a long, multi-step job runs with far less hand-holding, and you've got something concrete to check the result against. The same file works just as well in a plain chat.
**One folder, one file each.** I keep mine in one place, named so I can find them. To use one: open the file, copy it into whatever I'm using that day, paste in the specifics, go. Because it's just text, it works in a chat, a writing tool, or my agent setup. I use your approved AI tool day to day, and now and then I'll get a second opinion on a fiddly technical skill from a coding tool. Pick whatever connects to your own stack. Nothing's locked to one app.
I'm not precious about them. A skill that stops earning its keep gets deleted. One that keeps tripping on the same thing gets one line added. Living notes, not monuments.
**The deep end, when you're ready.** You can skip everything in this aside and still get the full win of this chapter. This is the power-user tier, for the day you want it.
**At full strength, the skills write themselves.** My own deep-end setup runs on Hermes Agent, a tool by Nous Research. In plain terms it's an AI assistant that plugs into your apps, keeps one memory across all of them, and works away in the background. The part that matters for this chapter: as it works it learns, and it turns those lessons into reusable skills on its own. I don't write them up, it does.
Plenty of people run something else here. OpenClaw and Paperclip are popular, or Perplexity Computer if you want a more corporate-friendly option. They're the power-user tier, they take a bit of setup, and you don't need any of them to get today's win.
A slice of my Hermes Agent working unprompted. The line that matters is the last one: it rewrote its own skill, so it does the job better next time. That is a skill, written automatically.
## Your turn
**Build your first skill today. Pick one task you did at least three times in the last fortnight.**
1. Open a blank note. Any plain text or notes app works to start.
2. Write the purpose in one line, like "Turn my messy meeting notes into a clean summary with decisions and action items."
3. Write how you do it well: inputs, steps in order, what you always check, the shape of output you want.
4. Add your best prompt at the bottom.
5. Test it on one real example. Read the output like a fussy editor. Where it falls short, don't re-prompt by hand. Edit the file so next time is better.
6. Save it with a clear name like "weekly update", somewhere you'll find it again.
From then on, running it is: open the file, copy it in, paste in today's specifics, send. A recurring chore becomes a one-line job.
**The copy-paste prompt.** Paste this in, then describe the task.
```
I want to turn a task I do repeatedly into a reusable skill, saved as a plain text note I can
reuse across different AI tools.
The task is: [describe the task in one or two sentences].
Here is roughly how I do it now: [describe your current steps, or paste an
example of the input you start with and the output you want].
Please write me a skill file as plain text with these sections, in this order:
- Purpose: one line on what this skill does.
- When to use it: the trigger or situation that calls for it.
- Inputs: exactly what I need to provide each time I run it.
- Safety checks: what I must verify before trusting or sending the output.
- Process: the steps to follow, in order, in plain language.
- Prompt: a ready-to-use prompt I can copy, with clear [placeholders] for my
inputs.
- Output: what a good finished result looks like.
- Review: the final human check before this goes anywhere.
Keep it plain and specific. No jargon. Ask me up to five questions first if
anything is unclear, then write the file.
```
**And that presentation builder?** It's one of the nine starter skills you get with this guide, ready to run, so you can see exactly how a skill this powerful is built.
**The starter shape.** Every skill in the starter kit follows the same eight-part shape, so once you know one you know them all. Copy this skeleton into a new note and fill it in:
```
# Skill: [name]
## Purpose
One line on what this does and why.
## When to use it
The situation that should make you reach for this.
## Inputs
- [What you paste in each time]
- [Anything time-sensitive lives here, not below]
## Safety checks
- [What to verify before trusting the result]
- [What must never go into this file]
## Process
1. [Step one]
2. [Step two]
3. [Step three]
## Prompt
[Your ready-to-use prompt, with [placeholders] for inputs.]
## Output
What a good finished result looks like.
## Review
The human check before this goes anywhere.
```
**Do this now.** Pick the single task you've repeated most this month. Open a blank note, give it the heading `# Skill:` and a name, and write just the one-line purpose. That first line is the whole job for now. The moment it has a name and a purpose, you've started your first skill.
## Keep it safe
**The risks here aren't dramatic, but they're real, so name them.**
A skill bakes in your assumptions. If your saved prompt has a blind spot, every output now carries that same blind spot, quietly and at scale.
- **Re-read every result.** Don't let "the skill did it" become an excuse to stop thinking. Read each new output the way you would if you'd written it yourself.
- **Keep time-sensitive details out of the file.** A skill that hard-codes a price, a policy, a name, or a product detail will keep repeating the old version long after it changed. Put anything that goes stale in the inputs you paste fresh, not in the file. Prune old ones every few months.
- **Watch what you store.** No real customer data, passwords, or confidential details in a skill file. The skill describes the process; the sensitive specifics get pasted in for that one run and not saved. Keep the folder somewhere you control.
- **Always end with a human check.** Never let a skill touch something important on its own. It can draft the email; you read it and hit send. That review step is the safety rail, not optional politeness.
## The payoff
**Write the job down once, and the work you already know how to do stops costing you the rebuild every single time.**
The standard moves out of your memory and into a file that doesn't get tired or have an off day. A recurring chore becomes a one-line task, the tenth result is as sharp as the first, and the whole thing is yours to share the moment someone else needs it.
That's the quiet engine behind almost everything else in this playbook, and you can start it today with a single line in a blank note. Now go pick your one task and write its first line.
