How I Build AI Skills That Actually Work
A 5-step recipe for turning any repeatable process into a reusable AI agent skill. Do, Codify, Run, Iterate, Skillify. The first four come from Evelyn Chapman. The fifth is what turns a process note into actual automation.
You don't write good AI skills. You build them by living the process first.
In this article, I want to share the 5-step recipe I use to turn any repeatable process into a reusable AI agent skill. The first four steps were nicely described by Evelyn Chapman: Do, Codify, Run, Iterate. The fifth one (Skillify) is my approach to ensure that the AI skills I create are interoperable and portable.
📬 If you enjoy this, subscribe to my newsletter for more on AI, Knowledge Management, and (Zen) Productivity.
TL;DR
The recipe in one sentence: do the process with AI as your hands, ask AI to write it down step by step, run that doc in a fresh session, fix what breaks, repeat until reliable, then convert the doc into a proper AI skill following the AI Agent Skills specification (https://agentskills.io/specification).
Here are the steps:
Introduction
Creating AI skills has become one of the most important skills in my toolbox, and I'm convinced more people should learn to do this well.
Early on, I tried writing AI skills from scratch. Sit down, open a blank file, try to capture the process from memory, ship it. That just didn't work out well. The skills would fail on the first real use, I'd patch those once or twice, then give up and rewrite everything from scratch a few weeks later.
What I eventually figured out is that the things you'd never think to write down are exactly the things that matter. The micro-decisions you make without noticing. The branches you take without noticing. The "I always check this field first" steps. Those only show up when you actually execute the process step by step with AI watching. You know your process, but a lot of what you know lives below conscious thought.
Reversing the order solved the problem. Instead of writing the skill from memory, I now run the process once with AI present. It watches, writes down what I did, tries it on its own, and surfaces the gaps. Then I package what's left into a real skill.
Let me show you how.
1. Do (With AI)
Perform the process end-to-end, with AI as your hands. You drive. It executes.
Give it exact, granular instructions:
- "Open this web page"
- "Click on that tab"
- "Open that document"
- "Update that note"
- "Set the status to X"
Whatever steps the process requires. It will take a while. That's fine, because the work you put in now is what the skill will look like later. You're demonstrating, AI is observing, and every click you make ends up encoded in the eventual skill. Don't optimize for speed here. Optimize for completeness.
2. Codify
Once the process is done, ask AI to write a document that describes everything you just did, step by step. You're not writing it. AI does, because it just watched. You review and correct.
The output you want is a markdown note that captures the process as a recipe. Preconditions, ordered steps, decision branches, expected outputs.
3. Run
Start a brand new AI session. No prior context. Tell it: "Read this document. Now execute this process for me."
The first run will make mistakes, and that's exactly what you want. Every mistake reveals something the doc left implicit, whether a step you skipped without thinking, a default value you forgot to mention, or a branch you take automatically that AI couldn't guess.
4. Iterate
For every mistake: tell AI what went wrong, have it update the process document to prevent that mistake next time, start another fresh session, run it again.
Repeat. Each iteration drives mistakes down and consistency up. Stop when execution is reliable enough for your tolerance. Usually 3 to 5 iterations is enough for a non-trivial process.
5. Skillify (My Addition)
Now convert the iterated process doc into a proper AI agent skill. Ask AI:
"Take this document and turn it into an AI agent skill. Follow the agent skills specification."
The skill must conform to the AI agent skills format: a SKILL.md file with name, description, body, and optional reference files. The canonical spec lives at agentskills.io/specification.
Once the skill exists, it slots into the rest of your skill library and triggers automatically when the right situation comes up. You stop running the process manually, which was the goal all along.
The Alternate Path: Skill-First
You don't actually have to write the prose note first. I often skip straight to the skill.
The trick is to mention the spec up front. Tell AI: "We are going to create an AI agent skill that respects the agent skills specification (https://agentskills.io/specification.md)." (actually providing that link in your prompt!). That one instruction makes a real difference. AI scaffolds the files in the right location, with the right name, and the right metadata. Skip it and you get a one-off markdown blob you'll have to restructure later. From there, describe what you want the skill to do, and iterate exactly like in the prose-note-first path.
Both paths land you in the same place. The skill is what matters.
Iteration Never Stops
The initial skill creation is just the beginning. Consider AI skills like the actual process behind: there's no finish line. Every time you use the skill, you'll notice little things that need to be improved, adjusted or fixed. Whenever I invoke a skill and something feels off (wrong output, missed step, weird edge case), I ask AI in the same session: "What did we do wrong? Update the skill so it works better next time."
AI patches the skill in place. The next invocation benefits from that patch. Run that pattern for six months and a skill will have absorbed dozens of small corrections. Every use is an opportunity for improvement.
The skill is "alive".
Note that you have to treat AI skills just like software developers treat code: carefully. Every modification of your existing AI skills has the potential to break things. Sometimes little details, sometimes big ones. That's the challenging part with current-generation AI; it's all somewhat unpredictable. To stay on the safe side, learn about tools such as Git to version your skills. That way, you'll be able to recover from mistakes if needed.
Going Meta: A Skill That Creates Skills
The natural endpoint of this loop is a skill that creates other skills.
Mine is called osk-writing-skill-creator. Whenever I want to turn something I've done with AI into a reusable skill, I invoke it. It produces a new skill that respects the spec without me having to remember every field, every filename, or every metadata convention.
Yes, it's meta. It's also the single most useful skill I've built, because every new skill it produces inherits the same conventions. One good skill-creation skill, built once, and every future skill starts strong.
Why the Spec Matters
The agent skills spec is the contract that AI agents already know. When your skills respect it:
- Discoverability: AI finds, triggers, and routes to your skills correctly
- Composability: they slot in next to other spec-compliant skills without friction
- Portability: they work across Claude Code, Codex, Gemini CLI, Copilot, and any future agent that adopts the spec
- No lock-in: switching AI providers doesn't strand your skill library. You move, the skills move with you
Independence is the real prize. Build skills against the spec, not against a specific platform, and you stay free to pick whichever AI is best at any given moment. No more being locked into one vendor's proprietary format and one vendor's roadmap.
The specification alone is not enough though. There's a lot more you can do to create awesome skills. But that'll be for another article!
Why This Approach Works
Four reasons this recipe outperforms writing skills from scratch:
- Demonstration beats documentation. Doing the process with AI captures the implicit micro-decisions you'd never surface from a blank page.
- Fresh sessions stress-test the doc. A clean session strips away the conversational scaffolding and exposes the gaps you couldn't see.
- The doc is the contract. When AI fails, you don't blame AI. You fix the doc. Every iteration improves the artifact, not the model.
- Skills compound. One skill is a tool. Twenty skills is a system. Three hundred is an assistant.
375+ Skills Later
My personal AI assistant runs on over 375 custom skills, all built using the approach I've just described. I use multiple ones every single day, and I rely on them for both my personal life and my entire business.
On the personal side, my assistant handles my morning check-ins and evening shutdowns, weekly planning sessions, journaling prompts, reading queue, book library, curated content stored in Readwise, health data & garmin watch synchronization, experiments, reflection, future-self letters, the surfacing of forgotten gems from my vault, etc. It tracks my relationships, prepares me for meetings, transcribes voice notes, and turns scattered daily-note ideas into proper permanent notes. The list of things I can do with all this is endless.
On the business side, it also does tons of things for me. Publishing to Ghost, Medium, LinkedIn, X, Typefully, the Knowii community. Customer tracking in my CRM. Newsletter drafting in my voice. Sales page audits. Analytics, SEO & AI SEO review. Product idea validation. Growth diagnostics. Launch preparation. Reviews of articles before they ship. Brand-aligned cover images and meme prompts. Every one of those skills came from the same recipe, and every one keeps improving.
Moreover, AI skills chain into each other. My weekly planning skill calls my goal review skill, which calls my content pipeline skill. Together they do what used to take me many hours. Multiply that across 375 skills and you've got an assistant that genuinely knows you, your voice, your vault, your business, your conventions, and acts on all of that intelligently.
You don't need 375 skills to start. You just need to know how to build the AI skills you need. Build those, and use those. The second one will be easier. By the tenth, you'll have a real system. Of course, at scale, there are additional challenges to consider, but you can already go really far with what we've just covered.
Ready to Build Your Own AI Skill Stack?
If you want a head start, grab the Obsidian Starter Kit. It ships with the structured Obsidian vault I use myself, plus templates, automation rules, and a growing library of AI agent skills already wired up. Same foundation those 375+ skills sit on. Trust me, it saves weeks of trial and error. And it's not just a random set of skills. It's a cohesive system with a solid architecture where skill composition is not an afterthought.
Start small. Pick one process you do regularly. Walk it through with AI, codify it, run it fresh, iterate, skillify. Do another one next week. By the end of the month you'll have a handful of skills already doing real work. By the end of the year, your AI assistant will look nothing like everyone else's. It will look like yours. You'll be surprised by all this can do.
That's it for today! ✨
About Sébastien
I'm Sébastien Dubois, and I'm on a mission to help knowledge workers escape information overload. After 20+ years in IT and seeing too many brilliant minds drowning in digital chaos, I've decided to help people build systems that actually work. Through the Knowii Community, my courses, products & services and my Website/Newsletter, I share practical and battle-tested systems.
I write about Knowledge Work, Personal Knowledge Management, Note-taking, Lifelong Learning, Personal Organization, Productivity, and more. I also craft lovely digital products and tools.
If you want to follow my work, then become a member and join our community.
Ready to get to the next level?
Found this valuable? Share it with someone who needs it.