Think of an Agent Skill as a reusable playbook for an AI agent.
A Large Language Model (LLM) provides intelligence. Tools provide capabilities. A Skill tells the agent how to apply that intelligence and those capabilities to a particular job, task, or routine.
So, in plain English:
LLM = brain
Tools = hands
Skill = standard operating procedure
Agent = the worker that combines all three
OpenAI’s Skills follow the open Agent Skills standard, so the same basic Skill package can be portable across compatible products rather than being a ChatGPT-only concept. (OpenAI Help Center)
What a Skill Actually Does
Imagine an agent already has access to GitHub, a terminal, Microsoft 365, and an n8n API.
Without a Skill, you might say:
Review this automation, inspect the workflow, check security, identify failure modes, and write an architecture assessment using our normal format.
Then you spend several prompts explaining what “our normal format” means.
A Skill packages that knowledge once:
When reviewing an automation:
inspect trigger → credentials → data movement → failure handling → retries → observability → human approval → security boundaries.
Use this architecture template.
Run this validation script.
Consult these enterprise standards when applicable.
Produce the final assessment in this format.
Now the user can simply say:
Review this n8n workflow.
The agent recognizes that the Skill applies and follows the playbook.
That is the fundamental value proposition: turn tacit procedural knowledge into reusable agent behavior.
Skills Versus Tools
This distinction is important.
A Skill usually does not provide the capability itself. It tells the agent what to do with capabilities it already has.
For example, a GitHub tool might expose functions like:
search_repository()
read_file()
create_issue()
create_pull_request()
A Skill could say:
For production-readiness reviews:
1. Inspect the repository architecture.
2. Find authentication and secret-management code.
3. Check deployment configuration.
4. Run the security-review script.
5. Categorize findings as Critical / High / Medium / Low.
6. Never modify code unless the user explicitly asks.
7. Produce findings using references/security-review-template.md.
The tool is the API surface.
The Skill is the expertise about how to use that API surface correctly.
OpenAI makes essentially the same distinction in its current product architecture: apps provide access to external data/actions, while Skills provide reusable workflow instructions; plugins can package the two together. (OpenAI Help Center)
How ChatGPT Uses Them
Skills use a clever mechanism called progressive disclosure.
ChatGPT does not dump every installed Skill into the context window. Instead, the agent initially sees essentially the Skill catalog: primarily each Skill's name and description. If your request matches one, the agent loads that Skill's SKILL.md. If that file references additional documentation or code, those resources are loaded only when needed. (Agent Skills)
Conceptually:
User request
↓
Agent
↓
"Do any Skills apply?"
↓
name + description
↓
Load matching SKILL.md
↓
Follow workflow
↓
Load references/scripts as necessary
↓
Use available tools
↓
Produce result
That architecture matters because you can potentially make dozens or hundreds of specialized workflows available without putting all their instructions into every prompt.
The Agent Skills Spec
The open specification is surprisingly lightweight.
At minimum, a Skill is just:
my-skill/
└── SKILL.md
A more realistic Skill looks like:
my-skill/
├── SKILL.md
├── scripts/
│ └── validate.py
├── references/
│ ├── architecture-standards.md
│ └── output-format.md
└── assets/
└── report-template.docx
The standard explicitly defines scripts/, references/, and assets/ as common optional resources. (Agent Skills)
The heart of everything is SKILL.md.
It consists of two pieces:
---
name: automation-architecture-review
description: >
Review automation and agentic systems for architecture,
reliability, security, observability, and maintainability.
Use when evaluating workflows, integrations, agents,
orchestration systems, or production automation designs.
---
# Automation Architecture Review
When reviewing a system:
1. Establish the system boundary.
2. Identify triggers, dependencies, and external systems.
3. Trace data and credential movement.
4. Evaluate failure modes and retry behavior.
5. Check observability and operational ownership.
6. Identify required human approval points.
For security requirements, read:
references/security-standards.md
For the final report format, read:
references/report-template.md
If machine-readable workflow files are provided,
run scripts/analyze_workflow.py first.
That is fundamentally the spec: YAML metadata followed by Markdown instructions.
The formal specification requires name and description. name is limited to 64 characters and uses lowercase letters, numbers, and hyphens; description can be up to 1,024 characters and should explain both what the Skill does and when the agent should use it. Optional fields include license, compatibility, metadata, and the experimental allowed-tools. (Agent Skills)
The Markdown body itself is intentionally flexible. You can put procedures, decision rules, examples, validation criteria, error handling, or references to supporting files there. (Agent Skills)
Why description Is Unusually Important
The description isn't just documentation.
It is effectively the Skill's routing rule.
The agent initially sees:
name: automation-architecture-review
description: Review automation and agentic systems...
but not necessarily the hundreds of lines underneath it.
So the description needs to answer:
“Under what circumstances should you activate me?”
The Agent Skills guidance explicitly says this metadata drives discovery and activation. Overly vague descriptions cause Skills not to trigger; overly broad descriptions cause them to trigger on unrelated tasks. (Agent Skills)
That means Skill design has two separate problems:
Description
↓
WHEN should I run?
SKILL.md
↓
WHAT should I do?
Scripts / references / assets
↓
WHAT resources do I need?
That mental model is extremely useful.
Where Scripts Become Interesting
Skills aren't limited to prompting.
Suppose an architectural review requires deterministic validation.
Instead of telling the LLM:
Carefully inspect this JSON and calculate whether every workflow has an error handler.
you can bundle:
scripts/
└── validate_error_handling.py
and instruct the agent:
Run `scripts/validate_error_handling.py` against every
workflow before completing the review.
Now you're combining:
LLM reasoning + deterministic software + procedural instructions.
That is much more reliable than trying to encode everything in natural-language prompting. The Agent Skills guidance specifically recommends scripts where operations become complex, fragile, or need repeatable behavior. (Agent Skills)
Where This Fits into the Broader Agent Stack
I would model the architecture like this:
AGENT
│
┌───────┼────────┐
│ │ │
Model Skills Tools
│ │ │
reasoning SOPs capabilities
│
┌──────┼──────┐
│ │ │
scripts refs assets
A Skill therefore sits between prompting and application code.
It is more durable than a prompt, lighter-weight than building another agent, and more procedural than simply attaching documents.
This is why Skills are especially compelling for enterprise AI. They create a versionable unit for encoding things such as architecture standards, review procedures, compliance processes, reporting conventions, tool-use patterns, escalation logic, and SME knowledge.
OpenAI now supports Skills in ChatGPT, Codex, and the API, and ChatGPT can automatically select installed Skills when they are relevant. You can also ask ChatGPT directly to create one, such as, “Create a Skill that reviews n8n workflows against our production automation standards.” (OpenAI Help Center)
The shortest definition I'd use with an executive or architect is:
An Agent Skill is a portable package of instructions, expertise, and optional code that teaches an AI agent how to perform a particular type of work consistently.
And technically:
Agent Skills is an open filesystem-based specification centered on a SKILL.md file containing activation metadata and natural-language instructions, with optional scripts, references, and assets loaded on demand. (Agent Skills)