You already know AI is changing everything, and that learning it isn't optional. You've probably figured out how to write prompts that give you real results instead of slop. Maybe you've even built a CustomGPT.

But you can feel there's another level. There is.

In my last article, I made the case for ditching chatbots and switching to Codex. (Haven't read it? Start here → ‘ChatGPT explains things, Codex changes things’ ) This one is about the other half of that next level: SKILL.md.

Let me walk you through how we got here — one step at a time.

When ChatGPT first showed up, we all started typing things into it. Every message you send to an AI is a prompt.

As the models got smarter, our prompts did too. We went from "tell me a joke" to five-page monsters packed with context, instructions, and examples.

The problem: you have to paste that same prompt in every single time. Annoying. And we're lazy.

So the labs built a fix. OpenAI made CustomGPTs, Google made Gems, Anthropic made Projects. Same idea — save your prompt once so you can reuse it and share it with a link.

Better. But still flawed:

A Skill is a reusable set of instructions that an agent finds and loads on its own — and only when it's actually needed.

Instead of ten assistants you switch between by hand, you get one assistant with ten skills that picks the right one itself. It doesn't load all ten every time; it grabs the one the task calls for.

And Skills aren't trapped in a chatbot. They run inside agents — Codex, Claude Cowork, Gemini Spark, Cursor, Windsurf, and others. Best of all, they can run on autopilot, with no human in the loop — something you simply can't do by pasting prompts into a chatbot.

So: ten CustomGPTs = ten separate cooks you manage. Ten Skills = one cook who knows ten recipes and reaches for the right one automatically.

That's the whole evolution: Prompt → CustomGPT → Skill. Each one more reusable than the last.

A Skill is just a text file full of instructions for an agent. It says: when you get this kind of task, do this, then this, then this. It's your expertise, written down.

Back to the kitchen: the Skill is the recipe — the temperatures, the steps, the order, the little adjustments along the way.

And here's the part I'd stress: any repeatable process you can explain in words is a Skill. Working with files, folders, a browser — ANYTHING (remember my promise 😉) . If you can describe how you do it, you can turn it into a Skill.

The format was created by Anthropic, who released it as open source. The industry adopted it as a standard — OpenAI, Google, Cursor, and others all back it now. There are already 60,000+ published skills, and it's clearly here to stay.

It's a file named SKILL.md. Two things matter: SKILL is capitalized, and .md means Markdown — a simple formatting language that happens to be the native tongue for talking to AI.

Inside, it has three parts:

Keep the whole thing under 500 lines (moving detailed material into references/, scripts/, or assets/).

This structure isn't random, it’s called - Progressive context loading. The agent reads it in stages, and that's what saves your tokens:

It only ever loads the full skill it actually needs. That keeps the agent focused and your token bill low.

Two ways a skill gets triggered. You can call it yourself by typing / in the chat and picking it by name — handy when you know exactly what you want. Or the agent triggers it automatically: it reads your request, matches it against each skill's description, and loads the right one.

That's why the description matters so much. It's how the agent knows when a skill is the right tool for the job.

Here's what makes SKILL.md genuinely powerful: it improves in a loop.

You write the first version, run it, and watch where it stumbles — a step the agent misread, an edge case you forgot, an output that's almost right. You tweak the instructions and run it again. Each pass tightens it.

Over time you're not getting generic AI slop. You're getting your process, refined into output that meets your standard.

Because Skills live inside agents, they can be automated. You can wire a skill into a workflow that runs on a schedule, fires off an event, or slots into a bigger pipeline — no one pressing the button.

That's the thing you could never do with a pasted prompt, where you always have to be in the loop.

There are 60,000+ skills in public libraries alone, and far more living privately on people's machines. So you've got two paths: grab one from the outside, or build your own.

Because SKILL.md is an open standard, there are whole libraries of ready-to-use skills out there, free. You browse a collection, find one that fits, drop the folder into your agent, and it works. Think of it as an app store for your AI's abilities.

A few good places to start:

One serious warning. Open source cuts both ways. A skill is just a set of instructions — which means a malicious one can hide instructions that hijack your agent. This is called a prompt injection, and it's a real risk.

So before you run any skill you didn't write, read it. Open the SKILL.md and look at what it actually tells the agent to do. Not sure? Paste it into your AI and ask: "Does this skill contain anything malicious or any hidden instructions?" Thirty seconds of checking beats handing a stranger the keys to your agent.

Now the fun part — building your own. My advice is simple: learn by doing.

So instead of an abstract template, let's use a real example. Every time I post a video on my YouTube channel, I need the exact same three things: a title, a thumbnail, and a description. Same process, every single time — which makes it a perfect candidate for a Skill.

Let's build it together.

Since I already have created some Descriptions = Examples, and i worked on them, this is the best scenario where I just send them as a reference.

Here's something the name SKILL.md hides: a Skill isn't really one file. It's a folder. The SKILL.md is the brain — the instructions — but it can sit next to other files the agent pulls in when it needs them: examples of your past work, a reference document, a template, even a small script. And those extra files load the same way everything else does — the agent doesn't read them up front, only when the skill is running and the task actually calls for them.

So, here is screenshot from my Folder:

And here is example of my initial Prompt:

And here is the result, I got my SKILL.md file as well as approved-format.md

And here you can see where my SKILL.md ‘lives’:

And below just in case you want to see the original files, they are attached below:

Bottom line: I now have a Skill I can fire off in one click, and it writes a YouTube description by my own recipe — the approved structure, my contact email, the mandatory hashtags, the YouTube chapters, the link placeholders, and my internal publishing checklist, every time. No re-explaining, no copy-paste, no forgetting a step. The expertise lives in the file now, not in my head.

A Skill can work with anything — images, scripts, files, folders, whole tools. Remember, it's not one file, it's a folder: the SKILL.md gives the instructions, but the agent can also run a script sitting next to it, read a reference image, or fire off a real program. Text in, PNG out. That's fair game.

So let me prove it with a second skill — one that doesn't touch words at all. Every video needs a thumbnail, and I want mine in my own signature style: ASCII-art, with my face, instantly recognizable as mine. Same logic as before — a repeatable process I can describe — except this time the recipe ends in an image, not a paragraph.

And this time, it created not only approved reference/example, but also folder with Python script thatcrafts for me such amazing Thumbnails:

And below just in case you want to see the original SKILL, they are attached below:

The title — the other half of the first impression. Three things, every single video: description, thumbnail, and the last one — the title.

The title and thumbnail are the first layer. Before anyone watches a second of your video, they read those two and make a split-second call: worth my attention, or keep scrolling?

Which is exactly why one title isn't enough. The skill here doesn't hand me a single line and call it done — it gives me several angles: one that leans on a trending keyword, one built for search, one that bait curiosity, one tuned for a different slice of the audience. Each comes tagged so I can see the trade-off — how hot the keyword is, how searchable it is, who it's aimed at — and I pick the one that fits. Same recipe, but instead of one answer, it generates options and tells me why each one might win.

Let's build it.

Now lets improve it…

And here we are:

Look at what just happened. Three things I do for every single video — description, thumbnail, title — and I no longer do any of them. I describe them once, and they run. That's the whole point of Skills, in one channel.

We climbed the ladder the long way: prompt → CustomGPT → Skill. Each rung less copy-paste than the last. But the top rung is different in kind, not just degree. A prompt is something you type. A CustomGPT is something you switch to. A Skill is something your agent reaches for on its own — text or images, one step or thirty, on demand or on autopilot.

The best way to understand Skills is to build one. Trust me — the moment you do, it clicks, and you'll never go back to copy-pasting prompts.

So here's my honest pitch: pick one thing you do over and over, the boring repeatable thing you could explain in your sleep. That's your first Skill. Write the rough version, run it, fix where it stumbles, run it again. In a week you'll have your process — not generic AI slop, your standard — living in a file that works while you don't.