Agents Are Learning to Write Their Own SKILL.md Files

The Agent Skills open standard today, and the 2026 research on agents that write their own skills.

TL;DR: In late 2025, "Agent Skills" became a thing — a dead-simple way to teach an AI agent a task: a folder with a SKILL.md

file (some instructions in Markdown). It's already an open standard. The wild part is what's coming next: agents that write their own skills. I built a demo where an agent solves a task the hard way once, saves a real SKILL.md

, and then reuses it — cutting its total effort almost in half. ~130 lines, no API key.

If you've used Claude Code or similar tools lately, you've probably seen SKILL.md

files. The idea is refreshingly low-tech. A "skill" is just a folder with a Markdown file that says how to do something:

---
name: csv-to-markdown
description: Turn comma-separated text into a Markdown table. Use when the input looks
  like CSV and the user wants a table.
---


## Instructions
Split the text into rows on newlines and columns on commas. Make the first row the
header, add a `---` divider row, then format every row as `| a | b | c |`.

That's it. No SDK, no config. Anthropic introduced this in October 2025 and then published it as an open standard (agentskills.io) in December 2025, so the same skill folder now works across ~30+ different agent tools (Claude Code, Cursor, Copilot, and more).

The full rules are short (agentskills.io/specification): the only required fields are name

(1–64 chars, lowercase-with-hyphens, and it must match the folder name) and description

(≤1024 chars, saying what it does and when to use it). Everything else — license

, metadata

, compatibility

, allowed-tools

— is optional. That's the whole spec. The SKILL.md

files my demo writes follow it to the letter, so they'd load unmodified in any compatible CLI.

Here's the smart part. If you just dumped 50 skills' worth of instructions into the agent's context, you'd fill it up and leave no room for actual work. So skills load in stages:

name

and one-line description

of every skill (tiny).So the agent can have hundreds of skills installed and barely pay for it — it only reads the short descriptions until one matches, then pulls in the details. My demo shows the math: to use 1 skill out of 3 installed, everything costs ~1500 "tokens"; the SKILL.md way costs ~560. That gap gets huge as your library grows.

This is also why people say skills and MCP are teammates, not rivals: MCP is how an agent connects to tools; a skill is how an agent knows the procedure for using them.

Today, humans write SKILL.md

files. The 2026 research is about agents that write their own — and get better over time as their skill library grows. This goes back to Voyager (2023), an agent that played Minecraft and saved working code as reusable skills, getting dramatically faster at the game. The new wave makes it general:

.memory.md

of notes about itself.The common thread: solve it once, save the recipe, reuse it forever — and let the collection get smarter on its own.

📄

The "this is the future" link:Anthropic's own writeup,[, and the open standard at]Equipping agents for the real world with Agent Skills. For the research direction,[agentskills.io][MUSE-Autoskill (arXiv:2605.27366)]and[Skill-Pro (arXiv:2602.01869)]are the clearest reads on agents that grow their own skill libraries.

This isn't theoretical — the exact pattern from my demo already ships in coding CLIs. In Claude Code, a skill is just a folder under .claude/skills/

in your repo:

mkdir -p .claude/skills/csv-to-markdown
$EDITOR .claude/skills/csv-to-markdown/SKILL.md   # same SKILL.md format as my demo

Now the agent loads only that skill's one-line description

until a task matches — then pulls in the full instructions (that's progressive disclosure doing its job). Type /skills

inside the CLI to see what's loaded.

The best part: because it's an open standard, the same folder works unmodified across tools. You're not locked in:

Write the skill once, use it everywhere. The future bit my demo points at: instead of you hand-writing that file, the agent writes it for itself after solving the task the first time — and from then on, your repo quietly accumulates a library of skills your agent earned.

Same stream of 7 tasks. "Cost" is how much effort each one took.

[5] csv-to-markdown  learned it and wrote SKILL.md
[5] slugify          learned it and wrote SKILL.md
[1] csv-to-markdown  reused skill 'csv-to-markdown'   ← cheap now
[5] extract-emails   learned it and wrote SKILL.md
[1] slugify          reused skill 'slugify'
[1] csv-to-markdown  reused skill 'csv-to-markdown'
[1] extract-emails   reused skill 'extract-emails'

It writes real SKILL.md files into a

./skills

folder you can open. The first time it sees a task it pays full price; after that, it finds its own saved skill and reuses it for cheap.Two big reasons engineers should care:

Agents stop repeating themselves. Right now most agents re-derive the same thing over and over, paying for it every time. A skill library means "figure it out once, then it's free" — like a teammate who writes things down instead of relearning them daily.

A whole new ecosystem. There are already 65,000+ shared skills and a scramble to build "the npm of agent skills" — registries and marketplaces where you install a skill like a package. Skills are becoming a unit of shareable expertise: a senior engineer's know-how, packaged in a folder, that any agent can pick up.

Tools tell an agent

what it can do. Skills tell ithow to do things well— and soon, agents will write that part themselves, and trade it with each other.

git clone https://github.com/Shridhar-2205/living-software
cd living-software/06-agent-skills
python demo.py
cat skills/csv-to-markdown/SKILL.md   # a skill the agent wrote itself

Honest note: this is a POC. Real systems decide when a new skill is worth saving, test it, and refine it over time (that's exactly what the 2026 papers above tackle). Mine keeps that part simple so the core idea — learn once, save a SKILL.md, reuse it — is easy to see.

Written by Shridhar Shah, Senior Software Engineer at Outshift by Cisco — I work on AI agents, search, and how they "think." Part 6 of "Toward Living Software." GitHub · LinkedIn

Sources:Anthropic, "Equipping agents for the real world with Agent Skills" (2025) and the Agent Skills open standard (agentskills.io); Voyager (arXiv:2305.16291); MUSE-Autoskill (arXiv:2605.27366); Memento-Skills (arXiv:2603.18743); Skill-Pro (arXiv:2602.01869); MemSkill (arXiv:2602.02474).