How to Build ChatGPT Skills (Better than 99% of People)

One well-written skill is the difference between an email that takes ChatGPT eight minutes and comes back generic, and one that comes back on brand in seconds, ready to send. That jump, from asking the tool questions to handing it real work, is what ChatGPT skills give you, and it's the single most useful thing to learn in ChatGPT right now. This guide covers what a skill is, the exact process I use to build one that works, the framework that decides whether a skill fires when it should, and how skills combine into something bigger than any one of them.

Watch: the full walkthrough this article is based on, How to Build ChatGPT Skills Better Than 99% of People.

Build a skill in the opposite order to what most first attempts do. Do the task once, with the agent, step by step. Verify it. Fix what it got wrong. Only then save it. Start from the skill creator instead, and you can burn 20 minutes and a pile of tokens building a skill for something the tool can't actually do. Doing the job first proves it's possible before you commit to automating it.

What a ChatGPT skill is

A skill is a reusable set of instructions that tells an agent exactly how to do a specific task. Not a prompt you paste in each time. A file it reads when it needs it.

The format is an open standard originally developed by Anthropic and now adopted across the industry, which is why the same skill runs in ChatGPT Work, Codex and Claude. In its simplest form a skill is a folder with a SKILL.md file in it, and nothing else.

Here's what running one looks like. We have a skill that creates the branded assets for our weekly 9x live workshops, something we used to do by hand in Figma. I call it, give it the event name, say "Master Skills in ChatGPT", and tell it I'm the host. The first thing it comes back with isn't the image. It's a question: is this a free session or a paid one? It asks because the skill names that as something it needs, and the design differs between the two. Thirty seconds later I have all four assets we use, the large thumbnail, the smaller email version, the square for our community platform, and the banner, each with the title and my face on it. The old way took 10 to 15 minutes an event. I gave it one line, and the finished assets came back without me specifying a background, a font, a dimension or a layout, because all of that already lives in the skill.

That's the shift. You define the workflow once and run it with a single command, the results come out consistent because the skill locks in how the job is done, and because you can share a skill, the whole team gets the expertise inside it. The bottleneck used to be that a designer had to make every asset. Now anyone on the team can publish a workshop.

The three layers of a skill

Skills work through progressive disclosure, which sounds technical and is straightforward once you see the shape of it.

Metadata is always loaded: the name and description, sitting at the top of the file. This is how the agent knows the skill exists and roughly when it's relevant. It's the only part always in context.

Instructions are the step-by-step workflow, read only when the skill is triggered. This is where the real length lives, and it costs you nothing until it's needed.

Resources are the supporting scripts, templates and assets, loaded only when a run calls for them. Our asset skill holds the brand fonts, photos of me and my co-founders, the background images and a few scripts. On the run above it used my photo and the light backgrounds, and never touched my co-founders' images, because the job didn't need them.

The analogy that lands with teams is a filing cabinet. The old way of building a custom GPT meant one enormous prompt holding everything the agent might ever need, all in context at once, including the parts irrelevant to today's job, which is exactly what confuses it and degrades the output. A skills-based agent just keeps the tabs: it knows it can write a LinkedIn post, a newsletter or an event asset, and only when you ask does it pull that one folder and read it.

There's a second saving that's easy to miss. Skills tend to write themselves small deterministic scripts for the parts that don't need judgement. Resizing an image doesn't need a model to reason about it. So the agent moves from working things out to simply executing, and only the genuinely dynamic parts consume real thinking. Fewer tokens, and more consistency.

How to build a skill, step by step

Here's the process on a real skill, a generator for Twitter-style images to use on social. Don't fixate on the example; the sequence is the point.

Step one: brief it, and do it once. I put the assets it needs in a project folder: a reference image in the style I want, my own photo, the verified-tick icon, and the font. Then I walked ChatGPT through the task in a single prompt: here's a tweet image that performs well, make one for me, use my name, my handle, my photo and this font, at this aspect ratio, and here's the first tweet. Not a hundred of them. One.

Step two: refine until it's right. The first version was already close. The font could be bigger, since there was more room on one side than the other, so I worked back and forth with it until it was exactly right, and then had it produce a dark-mode version too, because that's something I wanted the finished skill to handle.

Step three: now save it. With a working result in front of me, I called the built-in skill creator, gave the skill a name, and let it write the file. It created and installed the skill in one go, so it was immediately available.

Step four: check what it saved, then use it. I always open the new skill to see what it bundled. For someone else to run this, it needs my photo, the tick icon and the font file, and it had packaged all three into the skill's assets. Sometimes it forgets one, so this check matters. Then I tested it properly in a fresh session: seven tweets at once, alternating light and dark. It's trained on doing one, but because skills are agentic it handled the batch in under a minute. It got the line breaks wrong, so I corrected it in the chat first, then updated the skill.

You're not writing any of this by hand. OpenAI's guidance says the same: your job is to define the workflow clearly, not to author the file. Understanding the structure matters so you can tell when it's gone wrong. Writing it yourself doesn't.

The three types of skill input

This is the framework that separates a beginner skill from a good one. When you design a skill, decide where each piece of information comes from, and there are three sources.

Hardcoded in the skill. The things that never change, baked into the file and its resources. For the tweet generator, that's the design decisions and the reference files.

Fetched from a source. Information the skill pulls at run time through a connector or plugin: a morning-routine skill that reads your calendar, or a reporting skill that pulls from your data warehouse.

Provided in the prompt when the skill is called. The details that change every run. This is the one people miss. When I call the asset skill with nothing else, it stops and asks for the event title, whether it's free or paid, and who's hosting, because the skill tells it to. As the builder, you decide what the caller must supply and what the sensible default is. For the tweet skill I set two rules: always ask for the tweet text if it isn't given, and default to light mode unless dark is requested. Get this right, especially for skills other people will run, and the skill behaves predictably instead of guessing.

How skills call other skills

This is where it stops being a shortcut and starts being a system, because a skill can call another skill.

Take the marketing email from the top of this article. We have a create marketing email skill that holds our email template and voice. We also have a weekly newsletter skill that checks our content sources, new videos, new workshops, anything we've shipped, assembles the update, and then, when it's time to actually write the email, calls the create marketing email skill rather than repeating those instructions. Our publish-a-workshop skill does the same: it calls the event asset skill to make the images, then the create marketing email skill to draft the invitation.

The rule that falls out of this is worth holding on to. Build the smallest layer once, then compose. Because the email skill knows nothing about newsletters specifically, it's reused everywhere an email is needed, and if we ever change our template we update one skill, not thirty. Anyone who just needs a quick one-off email has it ready too.

How to update a skill

Skills aren't finished when you install them. They're company processes, and processes change.

The loop is: build it, use it on real work, check the output, refine. When the tweet skill got the line breaks wrong, I didn't open the file. I corrected the behaviour in the chat, then called the skill creator and told it what to fix. You update a skill exactly the way you created it.

One portability note, because it comes up every time we teach this. A skill you build in ChatGPT's desktop app lives locally, so it isn't in the web version until you upload it: turn the folder into a .zip or a .skill file, or have the agent zip it for you, then upload it under Plugins. The reverse works too, and ChatGPT even detects Claude skill files already on your computer and offers to import them, because Claude's documentation describes the same folder and file structure. The one thing to check is that any connector the skill depends on exists on the other side.

Which skill to build first

Don't start with the most impressive thing you can imagine. Start with the job you did last week and will do again next week.

A receipts skill is the example I point people at: read a receipt photo, pull out the fields, file the image by month, add a row to the spreadsheet. Small enough to build in one sitting, and it earns its keep immediately. The eight jobs we filmed end to end all started the same way.

For a team, the payoff compounds. A domain expert builds the skill once and everyone runs it. A new starter arrives to fifteen skills that already encode how the company does things, instead of a fortnight of asking.

Common questions

What is a ChatGPT skill? A folder containing a SKILL.md file with instructions that teach the agent how to do a specific task, plus any scripts or templates it needs.

Do I need to write the file myself? No. Use the built-in skill creator after doing the task once. Understand the structure so you can spot problems, but let the agent do the writing.

What's the difference between a skill and a custom GPT? A custom GPT carries all its instructions up front, in context at once. A skill keeps its instructions in a file the agent only reads when the task calls for it, so it stays fast and doesn't get confused between unrelated jobs.

Do ChatGPT skills work in Claude? Yes, and the reverse. Both use the same open format. Check that any connectors the skill relies on exist on the other side.

Why does my skill never trigger on its own? Almost always the description. It's the only part always in context, so it needs to state plainly when the skill should run and when it shouldn't.

How many skills should I build? Several small ones beats one large one. Small skills can call each other; a large one only ever does its own job.

The bottleneck was never writing the file. It's spotting which parts of your week are worth turning into a skill, and briefing them well enough that the output is usable. That's what we teach teams to do in our AI Automation programme.