Remember those huge prompts that started with lines like "act as a marketing expert with 20 years of experience"?
Then came the instructions about tone, format, rules, examples and everything the artificial intelligence was supposed to do.
Some of them ran several pages long.
And if you wanted to repeat the task in a new conversation, you often had to copy practically the same instructions all over again.
But that is changing.
Tools like Claude and Codex let you use something called AI Skills, also known as Agent Skills.
The idea is simple: instead of explaining to the AI over and over how to do a task, you can save a procedure for it to check whenever it needs to.
For example, you could create a Skill that explains how to write articles for your blog, follow your visual identity or review the quality of a software project.
So does that mean prompts are no longer useful?
Not exactly.
What is changing is the way we organize the knowledge we give to artificial intelligence.
And understanding that difference can save you a lot of work.
What are artificial intelligence Skills?
An AI Skill is a reusable set of instructions and resources that helps an artificial intelligence agent carry out a specific task.
Think of it as a procedures manual.
Imagine you hire someone to work at your company.
Instead of explaining to them every day how to prepare a report, you give them a document with the instructions, examples and rules they need to follow.
When they need to do that task, they check the manual.
Skills work in a similar way.
According to Anthropic's official documentation on Agent Skills, these resources can include instructions, reference files, templates and scripts that the agent uses when they are relevant.
For example, you can create a Skill that explains how to put together a sales presentation.
It could include your brand colors, the recommended structure, the fonts, a template and a program that checks the result.
That way, every time you ask for a presentation, a compatible agent can use those instructions without you having to repeat them in full.
But there is an important caveat: a Skill does not magically install new knowledge into the model, and it does not guarantee that the model will do every task correctly.
It works as a set of resources that the system checks and uses within its own capabilities and permissions.
Why are we moving from long prompts to Skills?
Prompts are still useful.
If you want to ask ChatGPT how a technology works or have it improve an email, a simple instruction is probably enough.
The problem shows up when you do the same task over and over.
Imagine that every week you need to prepare five articles for a blog.
Each article has to follow certain rules:
- Have a clear structure of headings and subheadings.
- Use verifiable sources.
- Keep a friendly, professional tone.
- Include links where appropriate.
- Avoid made-up information.
- Use a consistent editorial identity.
You could write all of those conditions into a prompt several pages long.
But what happens when you need to create another article?
What if you change one of the rules?
Or if someone else on your team needs to use exactly the same procedure?
Keeping all those instructions inside individual messages can become impractical.
A Skill lets you store your working rules in a reusable place.
That way you can update the procedure and use it across different tasks without rebuilding it every time.
The main difference is that a prompt says what you want to do right now, while a Skill can explain how to do a type of work correctly every time it is needed.
Anthropic explores this distinction in its guide Skills explained: How Skills compares to prompts, Projects, MCP, and subagents.
Skills vs. prompts: what is the difference?
Let's say you want to create an Instagram post about artificial intelligence.
With a prompt, you could write:
"Write an Instagram carousel about AI agents. Use simple language, explain each concept with examples and end with a question to spark conversation."
That instruction is perfectly valid.
Now imagine you publish content every day and want to keep a consistent style.
You could create a Skill that contains your editorial rules, formats, narrative structure and fact-checking criteria.
Then the prompt would be much simpler:
"Create a carousel about AI agents using our editorial procedure."
The Skill would provide the reusable instructions, as long as the system has it available and activates it correctly.
| Feature | Prompt | AI Skill |
|---|---|---|
| Main purpose | Request a task | Define how to carry out recurring tasks |
| Reuse | Can be copied or saved | Designed to be reused |
| Content | Instructions and context | Instructions, references and resources |
| Activation | Sent as part of a request | Can be loaded when it becomes relevant |
| Maintenance | You edit the prompt text | You update the Skill's files |
| Best for | One-off questions and tasks | Repetitive or specialized processes |
This does not mean a Skill is always better.
If you only need to translate a sentence, creating a whole procedure would probably be unnecessary.
But if you have to repeat a process with specific rules, a Skill can be much more practical.
How does a Skill work under the hood?
Even though the name sounds technical, the basic structure is fairly simple.
The open Agent Skills format uses a file called SKILL.md.
It is a document written in Markdown that contains information about the Skill and the instructions needed to carry it out.
It can also come with other files.
The structure might look like this:
mi-skill/
├── SKILL.md
├── scripts/
├── references/
└── assets/
Let's look at what each part is for.
SKILL.md: the main manual
It is the only required file in the format.
It includes the Skill's name, a description and the instructions the agent should follow.
The description is especially important because it helps determine when the Skill should be used.
Scripts: tools for carrying out tasks
A Skill can include programs written in, for example, Python or JavaScript.
These scripts make it possible to perform specific operations when the environment provides the permissions and tools to run them.
For example, a data analysis Skill could include a program to validate a CSV file.
References: documents to consult
This folder can contain additional information.
For example, API documentation, design rules or more detailed instructions.
The agent can check those files when it needs them, instead of loading all the information from the start.
Assets: templates and resources
This is where you can store files used during the process.
For example, a presentation template, reference images or a base document.
The resources available depend on the capabilities of the platform where the Skill runs.
You can check the exact requirements in the open Agent Skills specification.
The advantage of loading information only when it is needed
One of the most interesting features of Skills is a concept called progressive disclosure, which means revealing information gradually, step by step.
Its goal is to keep the model from having to receive all the instructions and documents of every available Skill at the same time.
Imagine you have ten Skills:
One for writing articles, another for generating presentations, one for analyzing documents and another for reviewing code.
If the agent loaded all of their full instructions with every request, it could use up a significant part of the available context.
With progressive loading, it can first identify the Skills by their names and descriptions.
When a task calls for one of them, it checks the corresponding instructions.
After that, it can access additional references and scripts if they are needed.
Anthropic's technical documentation describes this tiered way of working.
This helps organize the context better and can reduce the amount of information that needs to be loaded during certain tasks.
But it does not mean Skills are always faster or cheaper.
The result depends on their size, the implementation, the tools used and the number of steps required.
Practical example: creating a Skill for your blog
Let's build a simple example.
Imagine you publish articles about technology, artificial intelligence and automation.
You want all of them to have a professional structure, reliable sources and language that beginners can understand.
And you don't want to repeat the same instructions every time you prepare a new article.
You could create a Skill called blog-writing.
Its main file would contain something like this:
---
name: blog-writing
description: Creates and reviews educational articles for a technology blog. Use when articles, tutorials or guides are requested for publication on the blog.
---
# Writing blog articles
## Goal
Create useful, clear and verifiable articles about technology,
artificial intelligence and automation.
## Before writing
1. Identify the reader's search intent.
2. Define the problem the article will solve.
3. Consult official sources when appropriate.
4. Verify claims that may change over time.
## Editorial style
- Use clear, natural English.
- Explain technical terms the first time they are mentioned.
- Include practical examples.
- Avoid exaggerated phrases or unfounded promises.
- Do not invent personal experiences.
## Structure
1. Descriptive main title.
2. Introduction that presents a real problem.
3. Sections with clear subheadings.
4. Examples and comparisons when they add value.
5. Conclusion with concrete recommendations.
## Verification
- Prioritize primary sources.
- Distinguish facts from opinions.
- Check dates and data.
- Do not invent references or links.
## Delivery
Include an SEO title, a meta description and suggestions
for internal links when appropriate.
You don't need to memorize this code.
What matters is understanding what is happening.
We are placing the rules of a process inside a file the agent can reuse.
When you ask for an article, a compatible system will be able to check these instructions.
And if you later decide to change your editorial style, you can edit the Skill instead of updating dozens of different prompts.
This is a teaching example, not a Skill validated in a real project. To use it, you will need to place it in a location your tool supports and test that it works.
How to create your first AI Skill, step by step
You don't need to start with a complex procedure.
The best approach is to choose a repetitive task you already understand well.
Step 1. Identify the task you want to improve
Think of something you do every week.
It could be reviewing documents, preparing posts or creating an initial structure for your projects.
Avoid goals that are too broad, like "make the AI work better."
A concrete task is better:
"I want all my articles to follow the same editorial rules."
Step 2. Write down the procedure
Before creating any files, explain the process as if you were teaching it to someone new.
What should they do first?
What information do they need?
What mistakes should they avoid?
How do you check that the result is correct?
This exercise matters because a Skill with confusing instructions can produce equally confusing results.
Step 3. Create the SKILL.md file
Start with a simple Markdown file.
Define a name and a description that indicate when it should be used.
Then write the instructions step by step.
You don't need to include scripts or extra folders if the procedure can be handled with instructions alone.
Step 4. Add resources when they are needed
If you have templates, style guides or reference documents, you can organize them inside the Skill.
Avoid including unnecessary information.
And if the procedure requires running code, make sure the environment supports it and that the scripts have been reviewed.
Step 5. Install or register the Skill
How you do this depends on the tool.
For example, Claude Code lets you work with Skills in specific directories, while Codex also supports Skills inside repositories and user locations.
Not all platforms offer the same features or use identical configuration mechanisms.
That is why you should check the tool's documentation before installing it.
Step 6. Test it with real requests
Imagine you have already created your editorial Skill.
Ask for three articles on different topics and see whether it sticks to the rules.
Check whether it uses the right structure, whether it distinguishes facts from opinions and whether it provides verifiable sources.
Also try requests where the Skill should not kick in.
If a Skill meant for writing articles starts stepping into unrelated tasks, you probably need to improve its description.
Step 7. Improve the instructions
A Skill doesn't have to be perfect on the first try.
You can adjust its rules, add examples and remove unnecessary steps.
What matters is evaluating whether it actually improves the process.
What is the difference between a Skill and an AI agent?
It's easy to mix up the two terms.
An artificial intelligence agent is a system that can coordinate actions, use tools and carry out tasks to achieve certain goals.
A Skill is a resource that can give that agent reusable instructions and capabilities.
Think of it this way:
The agent is the one doing the work; the Skill is one of the manuals it can consult to do it.
For example, an agent in charge of preparing reports could have one Skill for analyzing spreadsheets and another for writing documents.
When it receives a task, it uses the appropriate tools and procedures.
But a Skill on its own is not necessarily an autonomous agent.
Nor does it have automatic access to the internet, your email or your private files.
Those capabilities depend on the tools and permissions available in the environment.
If you want to dig deeper into this difference, you can read our article on what artificial intelligence agents are and how they work.
Skills, MCP and agents: three concepts you should tell apart
If you are learning about AI automation, you have probably also heard of the Model Context Protocol, known as MCP.
Although they can work together, they don't serve the same purpose.
A Skill explains how to do a task.
A tool connected through MCP can provide structured access to a service's functions or information.
An agent coordinates the work using the capabilities available.
Imagine you need to prepare a report on your store's sales.
The agent receives the request.
A connection to the sales system can make it possible to look up the data, as long as it is authorized.
The Skill can specify how to organize the report, which calculations to check and which format to use.
Then the agent combines those pieces to complete the work.
This does not mean every implementation uses MCP or Skills.
You can build an agent without either of those components, or use only the tools you need.
Anthropic's official explanation of Skills, prompts, Projects, MCP and subagents goes deeper into these differences.
Do Skills only work with Claude?
No.
Although Anthropic was one of the companies that pushed this format forward, Agent Skills evolved into an open standard.
In December 2025, the standard was published to make it easier for different tools to adopt it.
And on October 22, 2026, Anthropic announced that it was donating it to the Agentic AI Foundation, which is affiliated with the Linux Foundation.
In its announcement, the company stated that more than 70 platforms had integrated the standard.
This includes tools related to software development and AI agents.
You can read the announcement at Anthropic — Donating Agent Skills to the Agentic AI Foundation.
Standardization matters because it aims to make it easier to reuse instructions and procedures across compatible tools.
However, the fact that several platforms recognize the format does not mean every Skill works exactly the same way on any system.
Some depend on specific tools, libraries, security settings or permissions that may not be available in another environment.
That is why it helps to distinguish between format compatibility and full execution compatibility.
Can I use Skills in Codex?
Yes.
OpenAI supports Skills in Codex and describes using them to extend agents' capabilities through specific instructions and resources.
For example, you can create Skills to review code, follow a project's conventions or run development procedures.
You can also share them inside a repository so they become part of your team's workflow.
OpenAI's documentation on how to build Skills explains the basic structure, activation and supported locations.
If you develop software, this way of organizing instructions can be especially interesting.
Instead of repeating the project's rules in every conversation, you can maintain specialized procedures and use them when they apply.
That said, it does not replace testing, code reviews or security checks.
When should you use a prompt and when should you use a Skill?
This is probably the most useful question in the whole article.
My recommendation is fairly simple.
Use a prompt when:
- You need to ask a one-off question.
- You want to handle a task you won't be repeating constantly.
- You are exploring ideas and don't have a defined procedure yet.
- You need to give specific context about a request.
Consider a Skill when:
- You repeat a task frequently.
- You need to keep consistent working rules.
- You have templates or files that are used in certain processes.
- You want to share procedures among team members.
- You need to update instructions without rebuilding all your prompts.
You can also use both.
In fact, that is probably the most useful combination.
The Skill defines the general procedure, and the prompt explains what you need to do in a specific situation.
Three common mistakes when creating Skills
Creating a Skill for absolutely everything
Not every task justifies a reusable procedure.
If you turn every simple instruction into a Skill, you can end up with a system that is hard to maintain.
Start with the processes that are truly repeated.
Writing instructions that are too general
A Skill that only says "work like an expert and deliver professional results" offers very little practical information.
It is better to define steps, review criteria and expected results.
The clearer the procedure, the easier it is to check whether it is being followed.
Installing unknown Skills without reviewing them
This is an especially important risk.
A Skill can contain instructions and scripts that the agent might run.
If you install a Skill from an unknown source, you could bring malicious instructions or unsafe code into your environment.
You shouldn't assume a Skill is trustworthy just because it has a lot of downloads or appears in a public repository.
Review its files, dependencies and permissions.
If it uses scripts, check what operations they perform.
Anthropic's documentation on Agent Skills also warns about the risks of using Skills from untrusted sources.
Do Skills make AI give better answers?
They can help improve the consistency and organization of certain processes.
For example, a well-designed Skill can make it easier for the agent to follow a checklist before delivering a document.
It can also reduce the need to repeat instructions across different conversations.
But we shouldn't confuse having a procedure with guaranteeing a result.
An agent can still misinterpret an instruction, use the wrong tool or generate inaccurate information.
That is why it is important to test how it works.
If a Skill is supposed to produce articles with sources, check whether it actually links to sources that exist.
If it is supposed to review code, check whether it catches known bugs.
And if it is supposed to create documents, make sure it follows the expected structures and formats.
What matters is not that the AI claims to have followed the procedure, but that you can verify the result.
Is it worth learning to create Skills in 2026?
If you use artificial intelligence only occasionally, you probably don't need to start here.
You can keep using simple prompts to handle many tasks.
But if you work with AI constantly to create content, develop software, analyze data or automate processes, learning to structure reusable instructions can be very useful.
Skills let you turn part of your know-how about doing a job into an organized resource.
That makes it easier to maintain, document and share procedures.
And because it uses an open format, you can reduce some of your reliance on instructions stored only inside a single conversation.
However, their real value is not in the SKILL.md file.
It is in the quality of the process you choose to document.
If you don't know how a task should be done correctly, saving it in a Skill won't automatically solve that problem.
Frequently asked questions about AI Skills
What is an AI Skill, in simple terms?
It is a set of reusable instructions and resources that an artificial intelligence agent can consult to carry out a specific task.
Do Skills replace prompts?
No. Prompts are still needed to give instructions and describe specific requests. Skills let you reuse procedures without repeating all their rules every time.
Do I need to know how to code to create a Skill?
Not necessarily. A basic Skill can consist of nothing more than a Markdown file with instructions. To add scripts or technical integrations, you may need programming knowledge.
What is SKILL.md?
It is the main file of the Agent Skills format. It contains metadata and the instructions the agent needs to understand when and how to use the Skill.
Can I share a Skill with other people?
Yes, when the format and the environment allow it. You can share the files with other people or add them to a compatible project, after first reviewing any sensitive information and dependencies.
Can a Skill connect to an API?
It can include instructions or scripts for using external services, but it needs a compatible environment, available tools and the right permissions. The Skill does not provide automatic access to any API.
Do Skills use fewer tokens than long prompts?
Progressive loading can reduce the amount of information added to the context up front. However, total usage depends on the procedure, the platform and the resources consulted.
Is a Skill the same thing as a custom GPT?
Not exactly. A custom assistant can bring together instructions, knowledge and tools within a product configuration. A Skill is a reusable format for packaging procedures and resources that a compatible system can load when it needs them.
Conclusion: prompts are not dead, but the way we work with AI is changing
For a long time, we focused on finding the perfect formula for writing a prompt.
We tried longer instructions, imaginary roles and increasingly complex structures.
But as we use artificial intelligence to handle entire processes, a different need emerges: organizing and reusing what works.
Skills address part of that need.
They let us document procedures, add resources and set criteria that can be used across different tasks.
That doesn't eliminate prompts.
It complements them.
The question is no longer just "how do I explain this to the AI?"
We can also ask ourselves: "how do I document this procedure so it can be used correctly next time?"
And that is the most interesting shift.
Because working better with artificial intelligence is not about writing longer and longer instructions.
It is about understanding what we want to solve, designing good processes and knowing how to check that the results are correct.
About the author
Rafael Azuaje is a computer engineer with experience in web development and UX/UI design. He shares educational content about artificial intelligence, automation and technology, with a practical approach aimed at helping people who are starting to use these tools to do so thoughtfully.
Information reviewed against documentation available as of November 17, 2026.



