AI Skills for AI Agents
Artificial Intelligence systems are becoming much more capable than traditional chatbots. Modern AI Agents can reason about tasks, use tools, retrieve information, remember context, communicate with external systems, and perform multi-step workflows.
Another important concept in this evolution is the AI Skill.
A Skill allows us to teach an AI system how to perform a particular task repeatedly and consistently.
Instead of explaining the same procedure every time we start a conversation, we can describe that procedure once and package it as a reusable Skill.
In this article, we will learn:
- What an AI Skill is
- Why Skills are useful
- How Skills relate to AI Agents
- What a
SKILL.mdfile is - The structure of an AI Skill
- How to create a Skill
- How to use Skills in ChatGPT
- How Skills work in Claude
- Skills vs Tools
- Skills vs RAG
- Skills vs MCP
- Skills vs AI Agents
- Practical examples for developers
- How Skills fit into our AI Agent architecture
What Is an AI Skill?
An AI Skill is a reusable set of instructions that teaches an AI system how to perform a particular type of task.
For example, suppose every time we ask an AI assistant to write an article we want it to:
- Create an SEO-friendly title.
- Write an introduction.
- Divide the article into H2 and H3 sections.
- Include code examples when appropriate.
- Add a conclusion.
- Suggest internal links.
- Follow a particular writing style.
Without a Skill, we might need to explain these requirements every time.
With a Skill, we define the workflow once.
The AI can then reuse it whenever that type of task appears.
Conceptually:
User Request
↓
AI Agent
↓
Relevant Skill
↓
Instructions
↓
Resources / Scripts / Examples
↓
Result
A Skill is therefore similar to giving an employee a standard operating procedure for performing a specific job.
Why Do We Need Skills?
Large language models already know how to perform many tasks.
However, there is a difference between:
Knowing something
and:
Knowing exactly how your organization wants the task performed
For example, an AI model may know how to write technical articles.
But it does not automatically know:
- Your preferred article structure
- Your terminology
- Your formatting conventions
- Your company’s workflow
- Your validation rules
- Which templates you use
- Which steps must always be performed
A Skill can capture these requirements.
Instead of repeatedly writing a long prompt such as:
Write an article.
Use H2 headings.
Add an introduction.
Include practical examples.
Explain concepts step by step.
Add a conclusion.
Do not make the explanation unnecessarily complex.
we can create a Skill containing those rules.
Then we might simply ask:
Write an article explaining MCP.
The Skill already knows the required process.
Skills Make AI More Consistent
One of the major advantages of Skills is consistency.
Without a Skill:
Request 1 → slightly different structure
Request 2 → different formatting
Request 3 → some steps forgotten
With a Skill:
Request
↓
Skill instructions
↓
Same workflow
↓
Consistent result
This becomes particularly important when AI Agents perform business tasks.
Examples include:
- Creating reports
- Reviewing code
- Writing documentation
- Preparing invoices
- Summarizing customer support requests
- Generating blog posts
- Analyzing data
- Reviewing security configurations
- Preparing project documentation
What Is a SKILL.md File?
A common Skill format uses a file called:
SKILL.md
The .md extension means that the file uses Markdown.
Markdown is a simple text formatting system commonly used in:
- GitHub
- README files
- Technical documentation
- AI instructions
The SKILL.md file acts as the instruction manual for the Skill.
For example:
# Technical Article Writer
## Purpose
Create clear technical articles for software developers.
## Inputs
The user provides:
- article topic
- target audience
- optional code language
## Instructions
1. Create an SEO-friendly title.
2. Explain the topic using simple language.
3. Use H2 and H3 headings.
4. Include practical examples.
5. Include code when useful.
6. Add a conclusion.
## Output
Return a complete article ready for publishing.
## Quality Checks
Before finishing:
- Verify technical accuracy.
- Remove unnecessary repetition.
- Check heading structure.
- Make sure examples match the explanation.
This simple document already represents a reusable AI Skill.
Basic Structure of an AI Skill
A Skill can be extremely simple or quite advanced.
A typical Skill directory might look like this:
technical-article-skill/
│
├── SKILL.md
│
├── examples/
│ └── example-article.md
│
├── templates/
│ └── article-template.md
│
└── scripts/
└── validate.py
The most important file is:
SKILL.md
The other files are optional.
They can provide additional resources that help the AI complete its work.
Step 1 — Choose a Task for Your Skill
The first step is deciding what the Skill should do.
Skills work particularly well with repeatable tasks.
Examples include:
Blog Article Writer
Python Code Reviewer
API Documentation Generator
Customer Email Writer
Security Checklist Reviewer
Database Query Analyzer
A good Skill should have a clear purpose.
For example:
Review Python code and identify bugs, security problems,
performance issues, and readability improvements.
This is better than creating a vague Skill such as:
Programming Skill
Smaller, focused Skills are usually easier to maintain and reuse.
Step 2 — Define the Inputs
Next, define what information the Skill needs.
For a code-review Skill, we might require:
Required input:
Source code
Optional input might include:
Programming language
Framework
Application type
Performance requirements
Our SKILL.md could therefore contain:
## Inputs
Required:
- Source code
Optional:
- Programming language
- Framework
- Application architecture
Step 3 — Define the Workflow
The most important section of the Skill is its workflow.
For example:
## Workflow
1. Read the complete source code.
2. Identify syntax or logical errors.
3. Check security problems.
4. Look for performance issues.
5. Examine code readability.
6. Suggest improvements.
7. Provide corrected code when necessary.
The AI now has a repeatable process.
Instead of deciding how to perform the review differently every time, it follows the Skill.
Step 4 — Define the Output Format
We can also tell the Skill exactly how results should be returned.
For example:
## Output Format
Return the review using:
### Summary
Short explanation of the code quality.
### Problems Found
List each important problem.
### Recommended Improvements
Explain suggested changes.
### Improved Code
Provide corrected code when useful.
This greatly improves consistency.
Step 5 — Add Quality Checks
A good Skill should also verify its own result.
For example:
## Final Checks
Before finishing:
- Do not invent problems that are not present.
- Verify that suggested code is syntactically valid.
- Explain important changes.
- Preserve existing functionality unless a change is necessary.
This acts like a final checklist.
Complete Example Skill
Now we can combine everything.
# Python Code Reviewer
## Purpose
Review Python source code and recommend improvements.
## Inputs
Required:
- Python source code
Optional:
- Framework
- Application architecture
- Performance requirements
## Workflow
1. Read the entire code.
2. Understand its purpose.
3. Identify bugs.
4. Check exception handling.
5. Look for security issues.
6. Identify performance problems.
7. Review readability and maintainability.
8. Recommend improvements.
9. Provide corrected code when useful.
## Output Format
### Summary
Describe the overall quality.
### Problems
Explain discovered problems.
### Improvements
Recommend changes.
### Improved Code
Provide corrected code when required.
## Final Checks
Before finishing:
- Preserve existing functionality.
- Do not invent nonexistent bugs.
- Check code correctness.
- Explain important modifications.
We now have a reusable Skill.
How to Create a Skill in ChatGPT
ChatGPT supports reusable Skills in eligible environments.
When Skills are available for your account or workspace, they can be found through the Plugins area.
The general process is:
ChatGPT
↓
Plugins
↓
Skills
↓
Create
ChatGPT provides different ways to create Skills.
One of the easiest is Create with chat.
You can simply tell ChatGPT:
Create a Skill that reviews Python code.
It should detect bugs, security problems, performance
issues and code-quality problems.
Return a structured code review and corrected code.
ChatGPT can help convert those requirements into a structured Skill.
You review the generated Skill and install it.
Another approach is to create the Skill manually using an editor.
You can also create the Skill files yourself and upload them.
Availability can depend on the ChatGPT plan, workspace and product configuration, so the exact options visible in the interface may differ between users.
Using a Skill in ChatGPT
After the Skill has been installed, ChatGPT can use it when it detects that the Skill matches your request.
For example, suppose we installed:
Python Code Reviewer
Then we ask:
Review this Python program.
ChatGPT can recognize that the code-review Skill is relevant.
Conceptually:
User
↓
"Review this Python code"
↓
ChatGPT
↓
Find relevant Skills
↓
Python Code Reviewer
↓
Follow SKILL.md
↓
Return structured review
In supported environments, Skills can also be selected explicitly instead of waiting for automatic selection.
How Skills Work in Claude
Claude also supports the concept of Agent Skills.
The basic architecture is very similar.
A Claude Skill is typically organized as a directory containing:
my-skill/
│
├── SKILL.md
├── scripts/
├── references/
└── other resources
Again, the important component is:
SKILL.md
The Skill provides procedural knowledge that Claude can load when the task requires it.
The basic idea is:
Claude Agent
↓
Detect relevant task
↓
Load Skill
↓
Read instructions/resources
↓
Perform task
This is important because the AI does not need every detailed instruction loaded into every conversation.
Instead, specialized instructions can be loaded when relevant.
Skills in ChatGPT and Claude
Although implementations may differ, the underlying idea is very similar.
ChatGPT Claude
│ │
├── Agent ├── Agent
│ │
├── Skill ├── Skill
│ │
├── SKILL.md ├── SKILL.md
│ │
├── Instructions ├── Instructions
│ │
└── Resources └── Resources
This is useful for developers because reusable agent procedures are becoming more portable.
Instead of embedding every workflow directly into application code, we can maintain specialized instructions separately.
Skill vs Prompt
A Skill may initially look similar to a prompt, but there is an important difference.
A normal prompt is usually created for one conversation or request.
For example:
Review this Python code and check for security problems.
A Skill defines the reusable procedure.
Python Security Review Skill
contains:
how to inspect the code
what security problems to check
how to report them
what validations to perform
Therefore:
Prompt
=
What we want now
while:
Skill
=
How the AI should perform this kind of task
Skill vs Tool
Skills and Tools are also different.
A Skill teaches the AI how to perform a task.
A Tool gives the AI the ability to perform an external operation.
For example:
Skill:
How to prepare a weather report
while a tool might provide:
Get current weather data
Combined:
User
↓
AI Agent
↓
Weather Report Skill
↓
Weather API Tool
↓
Weather Data
↓
Skill formats and validates report
↓
Final answer
Skills describe how.
Tools provide capabilities.
Skill vs RAG
In an earlier article in this series, we learned about Retrieval-Augmented Generation (RAG).
RAG provides information.
For example:
RAG
↓
Search company documents
↓
Return relevant knowledge
A Skill provides instructions.
Skill
↓
Explain how the company report must be created
Together:
AI Agent
↓
Skill
"How to create the report"
↓
RAG
"Retrieve the necessary company information"
↓
Report
Therefore:
Skill = Procedure
RAG = Knowledge Retrieval
Skill vs Memory
Memory allows the AI system to remember relevant information between interactions or during a conversation.
For example:
User preference:
Use Python examples.
A Skill instead describes a workflow.
For example:
When creating Python tutorials:
1. Explain the concept.
2. Show basic code.
3. Explain the code.
4. Add a practical example.
Therefore:
Memory
=
What should be remembered
while:
Skill
=
How a task should be performed
Skill vs MCP
We previously learned about the Model Context Protocol (MCP).
MCP allows AI applications to communicate with external tools, services and data sources through a standardized protocol.
For example:
AI Agent
↓
MCP
↓
Database
or:
AI Agent
↓
MCP
↓
External application
A Skill performs a different job.
The Skill tells the Agent how to use capabilities as part of a workflow.
For example:
User
↓
AI Agent
↓
Customer Analysis Skill
↓
MCP Tool
↓
Customer Database
↓
Data
↓
Skill analyzes data
↓
Customer Report
So we can think of them as:
Skill = Workflow knowledge
MCP = Standard connection mechanism
Skills and AI Agents
Skills become particularly powerful when used inside AI Agents.
Recall the architecture that we have gradually developed throughout this AI Agents Step-by-Step series.
Our Agent may contain:
AI Agent
│
├── LLM
│
├── Instructions
│
├── Planning
│
├── Tools
│
├── Memory
│
├── RAG
│
├── MCP
│
├── Guardrails
│
└── Skills
Each component has a different purpose.
LLM
Reasoning and language generation
Memory
Remember information
RAG
Retrieve knowledge
Tools
Perform actions
MCP
Connect tools and external systems
Guardrails
Control and protect behavior
Skills
Reusable task procedures
Together they create a much more capable AI Agent.
Example: Developer AI Agent
Imagine that we create an AI Agent for software development.
The Agent could have several Skills.
Developer Agent
│
├── Python Code Review Skill
├── API Documentation Skill
├── Unit Test Skill
├── SQL Review Skill
└── Security Review Skill
When the user asks:
Review this Python API.
the Agent might use:
Python Code Review Skill
and:
Security Review Skill
If the user then asks:
Generate API documentation.
the Agent can use:
API Documentation Skill
The same AI Agent therefore gains multiple specialized capabilities.
Skills Can Work Together
One important advantage of Skills is composition.
An Agent does not necessarily need only one Skill.
For a complex task it might combine several.
For example:
User:
Review my Python REST API and write documentation.
The Agent might use:
Python Code Review Skill
+
Security Review Skill
+
API Documentation Skill
Conceptually:
AI Agent
│
┌────────────┼────────────┐
↓ ↓ ↓
Code Review Security Documentation
Skill Skill Skill
│ │ │
└────────────┼────────────┘
↓
Final Result
This makes Skills useful building blocks for larger Agent systems.
Skills Can Contain Scripts and Resources
A Skill does not have to contain only text instructions.
Advanced Skills can also include supporting resources such as:
Templates
Examples
Schemas
Reference documents
Scripts
Validation utilities
For example:
invoice-skill/
│
├── SKILL.md
│
├── templates/
│ └── invoice-template.md
│
├── examples/
│ └── example-invoice.md
│
└── scripts/
└── validate_invoice.py
The instructions describe the workflow while the other resources support execution.
Security Considerations
Skills can contain instructions, files and sometimes executable scripts.
Therefore, Skills obtained from other people or external sources should be treated like other software components.
Before installing an external Skill:
- Review its instructions.
- Review included scripts.
- Check what resources it accesses.
- Understand what tools it may use.
- Only install Skills from sources you trust.
This becomes especially important when an Agent can access external services or perform actions.
Guardrails, permissions and human approval may still be required for sensitive workflows.
When Should You Create a Skill?
A useful question is:
Do I repeatedly explain the same process to the AI?
If the answer is yes, that workflow may be a good candidate for a Skill.
For example, if you repeatedly tell ChatGPT:
Write a technical article.
Use a simple introduction.
Explain concepts step by step.
Add architecture diagrams.
Include code examples.
Finish with a conclusion.
you could create:
Technical Article Writer Skill
and store those instructions once.
Skills as Reusable Knowledge for AI Agents
Skills represent an important change in how we build AI systems.
Previously, developers often placed large amounts of procedural instruction inside one system prompt.
For example:
System Prompt
- How to review code
- How to create reports
- How to write emails
- How to document APIs
- How to analyze databases
- How to validate output
...
This becomes difficult to maintain.
Skills allow us to separate these responsibilities.
Agent
│
├── code-review-skill
├── report-skill
├── email-skill
├── api-documentation-skill
└── database-analysis-skill
This is similar to modular software architecture.
Each Skill has one responsibility and can evolve independently.
Complete AI Agent Architecture
After following this AI Agents Step-by-Step series, we can now see how the different technologies fit together.
USER
│
↓
┌─────────────┐
│ AI AGENT │
└──────┬──────┘
│
┌────────────────┼────────────────┐
│ │ │
↓ ↓ ↓
Skills Memory RAG
│ │ │
↓ ↓ ↓
Workflows Remembered Data Knowledge
│
↓
Tools
│
↓
MCP
│
↓
External APIs / Databases / Services
Guardrails protect the workflow
An Agent can therefore:
Understand a goal
↓
Plan the task
↓
Select appropriate Skills
↓
Retrieve knowledge with RAG
↓
Use remembered context
↓
Call Tools
↓
Access external systems through MCP
↓
Apply Guardrails
↓
Evaluate the result
↓
Return the final answer
This architecture is much closer to how modern AI Agent systems are being designed.
Conclusion
An AI Skill is a reusable workflow that teaches an AI system how to perform a particular task consistently.
Instead of repeatedly explaining the same process, developers and users can package instructions, examples, templates, scripts and validation rules into a reusable Skill.
The central component is often:
SKILL.md
which acts as the instruction manual for the Skill.
Skills complement the other technologies we explored throughout this AI Agents Step-by-Step series:
Memory → remembers information
RAG → retrieves knowledge
Tools → perform actions
MCP → connects external systems
Guardrails → protect and control the Agent
Skills → teach reusable workflows
Together these components transform a simple chatbot into a much more capable AI Agent.
Skills are especially important because they allow Agent behavior to become modular, reusable and maintainable.
Instead of creating one enormous Agent containing every possible instruction, we can build smaller specialized Skills and allow the Agent to use the appropriate Skill when it needs it.
This concludes another important part of our journey toward understanding how modern AI Agents are built.
← Back to AI Agents – Step-by-Step