What Are Agent Skills?
I run a cross-border trade team. We don’t write code, but we now work alongside AI agents every day — for sale…
Why AI Agents Need a Playbook
I run a cross-border trade team. We don’t write code, but we now work alongside AI agents every day — for sales follow-ups, cold outreach, and content checks. The problem: an agent without instructions is just a very confident assistant that gets things wrong in three languages.
Early on, we pasted 2‑page prompts into every chat. That works once. It doesn’t scale, it doesn’t share, and it burns your context window on every new conversation. What we needed was something closer to a team playbook: a reusable, discoverable job description that an agent loads only when the work actually requires it.
That’s what agent skills are. And that’s why we built 365Skill — an open-source experiment to turn tactical knowledge into files that any AI agent can use.
---
What Is an Agent Skill?
An agent skill is a plain-text directory that serves as a reusable instruction pack for an AI agent. Think of it as a “job description” you can hand to the agent only when a matching task shows up.
The directory contains one mandatory file: SKILL.md, plus any optional resource files (data tables, examples, checklists). The skill file itself splits into two parts:
- Frontmatter (YAML metadata): skill name, one-line description, a trigger phrase that tells the agent “load me for this kind of work,” and sometimes a version number.
- Instruction body: the actual operational playbook — step-by-step logic, rules, examples, and boundaries.
The key design choice: agents don’t read the full skill on startup. They scan only names and descriptions. When a user says something like “write a follow-up email for a French logistics buyer,” the agent picks the relevant skill, reads it once, and executes. Context stays lean, and you get consistent output without bloating every prompt.
---
SKILL.md Anatomy: The Job Description in One File
Everything hinges on a single file. Here’s what goes into it.
| Section | What it holds | Why it matters |
|---|---|---|
| Name & Description | A human-readable ID and a one-sentence summary of what the skill does. | Agents browse these to decide when to activate the skill. |
| Triggers | Keywords or intents that signal “load this now.” | Prevents the agent from carrying 50 skills in memory at all times. |
| Body (Instructions) | Concrete steps, do/don’t rules, output formats, and decision points. | This is the executable playbook — what the agent actually follows. |
| Resource files (optional) | Spreadsheets, reference docs, style guides. | Grounds the skill in real data without hard-coding it into the prompt. |
No database, no API, no code. It’s just a file structure that any modern coding agent (Claude Code, Codex, Cursor, etc.) can read. At 365Skill we standardize this format so skills become portable across clients — you install them once and the agent picks them up.
---
Agent Skills vs. System Prompts vs. MCP Tools
Operators often mix up three concepts. Here’s the simplest distinction I use with my team:
| Mechanism | When the agent sees it | Shareable? | Versionable? | Context impact |
|---|---|---|---|---|
| System prompt | Always loaded, full text in every session. | Hard — usually copy-paste. | Manual at best. | High — constantly burns tokens. |
| MCP tool | Called on demand by the agent, runs external code. | Partially — requires server or API setup. | Tool-level, not behavior-level. | Low — returns minimal data. |
| Agent skill (SKILL.md) | Matched by trigger, read once per task. | Yes — it’s a plain folder, can live in git. | Full git-based versioning. | Low — only loaded when needed. |
Skills hit the sweet spot for business operators: they’re files you can share with your team, version like a sales playbook, and activate exactly when the task demands it. No engineering required to maintain them.
---
How to Write Your First Skill: A Worked Example
Let’s ground this. Suppose I want an AI agent to handle cold outreach follow-ups for cross-border sales — a task my team does 200+ times a month. Instead of pasting the same process every time, I create a skill.
I make a folder named “cross-border-follow-up”.
Inside, I place a SKILL.md file with frontmatter like:
- name: cross-border-follow-up
- description: Generates a 3-email follow-up sequence for international trade prospects.
- triggers: cold outreach, follow-up, sales sequence, trade email
Then the instruction body lays out the exact playbook:
- Ask for: prospect’s company, role, country, and the initial outreach date.
- Write three emails in plain English (no jargon):
- Email 1 (48 hours after first contact): gentle reminder, add one relevant industry data point. - Email 2 (Day 5): highlight a specific pain point common in their sector, suggest a short call. - Email 3 (Day 9): last check-in, leave the door open.
- Always include unsubscribe-friendly text, and never use more than 120 words per email.
- Format the answer as a numbered list with subject lines.
No code. I just write business instructions. My team stores this folder in a shared repo. When anyone uses our AI sales copilot, the agent detects “follow-up” in the request, loads this skill, and executes — same logic, every time. The tool we use for manual cold outreach, by the way, is our free AI Cold Outreach Email generator, but the skill approach works inside any compatible AI client.
---
How Agents Load Skills — And Why That Saves Context
A common concern from operators: “Won’t all these skills just eat up the token limit?” The design prevents that through on-demand loading.
The agent’s runtime keeps a lightweight index of available skills — name, description, and a few trigger terms. That index is maybe a few hundred words total. When a user’s request matches a trigger, the agent retrieves the full SKILL.md, reads it into memory, executes the task, and then discards the loaded instructions for the next turn.
You can have 30 skills in your library. The agent’s working context carries only the one you’re actually using right now. That means you can build deep, nuanced skills without worrying about overwhelming the system prompt or hitting token limits.
---
Bring Your Own Skills — and Version Them Like a Pro
Because a skill is just a directory of text files, you can:
- Store it in git along with your other business assets.
- Tag releases (v1.0, v1.1) so your team always uses the tested version.
- Fork and remix public skills for your own business — just like open-source code, but for operational knowledge.
That versioning is a game changer for cross-border sales teams where process changes every quarter (new markets, new regulations). Instead of Slack messages saying “everyone update their prompt,” you push a new tag, and agents automatically pick up the latest skill.
---
Where 365Skill Enters the Picture
At 365Skill, we’re putting this idea into practice with an open-source library (Apache-2.0). The repository contains:
- A standardized SKILL.md format any client can understand.
- A release strategy — skills have explicit version tags and changelogs.
- An evals system — we test skills against golden datasets to make sure they don’t degrade when we tweak them.
We use this library ourselves to explore how skills should be structured, shared, and evaluated. It’s a public experiment, and we publish everything so that operators, developers, and teams can fork it, contribute new skills, or just use it as a template for their own private libraries. And it sits alongside the rest of the 365 product family — all tools we built because we needed them in our own business first.
---
FAQ
How is an agent skill different from a long prompt?
A long prompt lives in your chat window and is either forgotten or manually copied across sessions. A skill is a file — discoverable, shareable, and versionable. Agents load it only when the task matches the trigger, so it doesn’t bloat the conversation.
Can I use agent skills with any AI assistant?
Modern coding agents like Claude Code, Codex, and Cursor support skill mechanisms in their own ways. Installation paths differ, so always check the client’s documentation. The SKILL.md format we use at 365Skill is designed to be portable across these platforms.
Do I have to write code to create a skill?
No. A skill is plain text with YAML frontmatter and natural-language instructions. If you can write a standard operating procedure, you can write a skill. Your developer can then store it in a repo and point the agent at it.
If I update a skill, will all agents pick up the change?
If you version your skills in a shared repository, agents that reload the skill index will grab the latest version. You can also pin specific versions in a team environment to avoid surprises. The same git workflows you use for code work for skills.
---
Ready to turn your best team processes into agent-ready playbooks? Start with the free AI Cold Outreach Email tool to see how standardized instructions improve output today. Then explore the open-source 365Skill library for format examples, ready-made skills, and the evals framework — all built to help operators like you make AI agents work reliably, without having to write a single line of code.