Agent Skills is now an open standard: what changes for your SKILL.md

MCP became the industry standard once Anthropic let go of it.

Now it has done the same with Agent Skills.

And that .claude/skills folder you wrote for Claude Code might be one step away from running on any agent.

Agent Skills are folders with a SKILL.md file that teach an AI agent a specific task, loaded only when the task calls for it. On October 22, 2026, Anthropic donated the Agent Skills standard to the Agentic AI Foundation, the Linux Foundation fund that already stewards MCP. In this post I'll cover what agent skills really are, why the donation matters more than it looks, and what to do with the skills you already have. With a real example: the eight skills that run this very blog.

TL;DR

• What it is: Agent Skills is the folder format with a SKILL.md (plus scripts and references) that teaches an agent a specific task. Since 10/22/2026 the standard belongs to the Agentic AI Foundation, not Anthropic.
• What was donated: the specification, the name and logo, the GitHub organization and the agentskills.io domain.
• Who uses it: more than 70 platforms have integrated the format since December 2025, according to Anthropic. Among them: ChatGPT, Cursor, GitHub Copilot and VS Code.
• Cost/Access: open standard. You don't need to be a foundation member to use it or contribute.
• What to do now: validate your skills against the spec, separate what's portable from what's tied to Claude Code, and review your description fields.

The context: why the Agent Skills donation matters

Rewind one year.

On December 9, 2025, the Linux Foundation announced the Agentic AI Foundation (AAIF) with three founding projects: Anthropic's MCP, Block's goose and OpenAI's AGENTS.md. From then on, MCP stopped being "Anthropic's protocol" and became neutral infrastructure. Competitors don't adopt a competitor's standard. They adopt a foundation's standard.

Skills followed the same script, only faster. Anthropic published the format as an open standard in December 2025. According to the October 22 announcement, since then more than 70 agent platforms have integrated it, roughly 1 million skills have been published, and there have been nearly 280 million installs.

What the donation changes is governance:

• Anthropic handed over the specification, name, logo, the GitHub org and the agentskills.io domain.
• Engineers from Anthropic, Google, OpenAI and other companies maintain the standard as individuals, not as company representatives. The lead maintainers are David Soria Parra and Mahesh Murag.
• The announced roadmap has three items: versioned releases, a formal change proposal process, and security guidance for people who write and install skills.

In dev terms: your SKILL.md spec now has a neutral owner, versions and a change process. That's the kind of thing that makes platform teams stop treating skills as "a Claude feature" and start treating them as a packaging format for knowledge.

And here's the point most people miss. The standard isn't the differentiator. Everyone gets the same format. The differentiator is what you put inside the folder: your team's process, your harness, the way you validate delivery. That's the kind of engineering we dig into every week at the Clã Beer and Code, with people shipping agents to production, not just reading announcements.

What agent skills are, in practice

A skill is a folder. That's it.

Inside, at minimum, a SKILL.md file with YAML frontmatter and Markdown instructions. Optionally, scripts/ (executable code), references/ (docs the agent reads when needed) and assets/ (templates, schemas, data) folders. That's the layout in the official specification.

The frontmatter has two required fields:

---
name: revisar-seo-post
description: Revisão de SEO on-page + trava de segurança do MCP que roda como GATE logo antes de publicar um post no blog Beer & Code. Acionar sempre que um post estiver pronto para subir ao MCP, ou quando o usuário pedir para revisar/auditar o SEO de um post.
---

The rules the spec enforces:

• name: up to 64 characters, lowercase letters, numbers and hyphens only. Can't start or end with a hyphen, no double hyphens. Must match the folder name.
• description: up to 1024 characters. Should say what the skill does and when to use it.
• Optional: license, compatibility (up to 500 characters, to declare environment requirements), metadata (free key-value map) and allowed-tools, which is still experimental and each agent implements its own way.

Progressive loading: the detail that makes skills work

A skill isn't a giant prompt pasted into context. The agent loads it in three layers, per the spec:

1. Metadata (~100 tokens per skill): only name and description enter the context at startup, for every installed skill.
2. Instructions (recommended under 5,000 tokens): the full SKILL.md body is loaded only when the agent decides to activate that skill.
3. Resources (on demand): files from scripts/, references/ and assets/ come in only when the task needs them.

That's why you can have dozens of skills installed without drowning the model. And that's why description is the most important field in the whole folder. It's the only thing the agent sees before deciding. Vague description, the skill never fires. Overpromising description, the skill fires at the wrong time.

It's context engineering in practice, the same logic we discussed when Anthropic cut Claude Code's system prompt: whatever is always in context has to be minimal and precise.

X-ray: the skills that run this blog

This post was produced by a Claude Code skills pipeline. So we can use the pipeline itself as the test subject.

I ran a simple check on the eight skills in the editorial repo's .claude/skills/:

for f in .claude/skills/*/SKILL.md; do
  dir=$(basename "$(dirname "$f")")
  name=$(awk '/^name:/{print $2; exit}' "$f")
  desc=$(awk '/^description:/{sub(/^description: /,""); print; exit}' "$f")
  echo "$dir name=$name desc_chars=$(printf %s "$desc" | wc -m) lines=$(wc -l < "$f")"
done

Result:

Three takeaways:

They all pass the basics. name matches the folder name, lowercase and hyphens only. No SKILL.md gets close to the recommended 500-line ceiling.

minerar-evergreen is right at the limit. 930 of 1024 description characters. It works today. But it's the skill that will break first when someone adds "just one more trigger". And an overly long description is a symptom: it's trying to do routing that belongs in the body.

Portability is the real problem, not the format. criar-post-blog has neat scripts/ and references/, all within the standard. But the audio step delegates the script rewrite to a Claude Code subagent (roteiro-narracao) via the Agent tool. And publishing depends on the blog's MCP server being configured in the session. The SKILL.md is portable. The environment it assumes isn't.

That's the point nobody mentions when celebrating the "open standard". The folder format travels. The harness dependencies don't.

What to do with the skills you already have

You don't need to migrate anything tomorrow. Anthropic makes it clear in the announcement that you can keep using the standard as is. But four things are worth half an hour.

Step 1: validate against the spec

The standard has a reference library, skills-ref, that checks frontmatter and naming conventions:

skills-ref validate .claude/skills/criar-post-blog

Common mistake: a folder named CriarPost with name: criar-post. Claude Code might even run it. An agent that follows the spec to the letter won't load it.

Step 2: declare what's tied to the harness

If the skill depends on a subagent, hook, specific MCP server or Claude Code tool, say so in the compatibility field:

---
name: criar-post-blog
description: Cria, agenda e publica posts completos no blog Beer & Code...
compatibility: Designed for Claude Code. Requires the beer-and-code-blog MCP server, ffmpeg, aws CLI and the roteiro-narracao subagent.
---

And in the body, write the fallback. "If no subagent is available, do X." Anyone opening the skill in another agent knows right away what will work and what won't.

Step 3: treat the description as a router

It's loaded every time, in every session, alongside the descriptions of all other skills. So:

• Start with what the skill does, in one sentence.
• List the real triggers ("when the user asks for X, Y or Z").
• Say what it does not do, if there's a neighboring skill it could be confused with. This blog's skills do that: planejar-pauta states it doesn't write posts and points to criar-post-blog.
• Cut the rest. Process details go in the body, not the description.

Step 4: read third-party skills before installing

A million published skills means a million folders of instructions and scripts your agent will run with your permissions. Skills are code. The foundation's own roadmap includes security guidance for installers, and for good reason. We've already seen a "clean" repository make Claude Code install malware. A skill with scripts/ is the same vector, with a formal invitation.

What about Codex, Gemini CLI, Cursor?

Here we need to separate what's announced from what's a bet.

Announced: Anthropic's post lists ChatGPT, Cursor, GitHub Copilot and VS Code among the platforms that have already integrated Agent Skills. On Google's side, an official Gemini CLI codelab shows a skill with a SKILL.md in the .agents/skills folder being discovered and used by Gemini CLI.

Not confirmed in the announcement: Codex shows up in Anthropic's text only as one of the agents developers wrote skill loaders for in October 2025. I found no announcement of native, official Codex support for the standard under AAIF governance. Treat it as a possibility, not a fact.

Also notice the path: .claude/skills is a Claude Code convention, .agents/skills shows up on the Gemini CLI side. The spec defines the folder format, not where it lives. With versioned releases and a proposal process, a common directory will very likely come up. Until then, a symlink does the job:

mkdir -p .agents
ln -s ../.claude/skills .agents/skills

Limitations and gotchas

• Portable format isn't portable behavior. Different models interpret the same instruction differently. A skill tuned for Claude may need adjustments on another agent. Without evals, you don't know.
• allowed-tools is experimental. The spec warns that support varies across implementations. Don't use this field as a security control.
• The spec will still change. Versioned releases and a formal proposal process are on the roadmap, not shipped. Follow agentskills.io and GitHub before building internal tooling on top of spec details.
• Skills don't replace MCP or AGENTS.md. MCP connects the agent to tools and data. AGENTS.md (or CLAUDE.md) is fixed project context. A skill is procedural knowledge loaded on demand. All three coexist, and all three now live in the same foundation.

Quick FAQ

What are agent skills? Folders with a SKILL.md file (frontmatter with name and description plus Markdown instructions) and, optionally, scripts, references and assets. The agent reads only the name and description at startup and loads the rest when the task calls for it. It's the format Anthropic created and has now donated to the Agentic AI Foundation.

What's the difference between Claude skills and Agent Skills? None in format. "Claude skills" is what many people call skills in Anthropic's ecosystem. Agent Skills is the name of the open standard, now under the AAIF. The SKILL.md running in Claude Code follows the same specification.

Do I need to change my skills because of the donation? No. Anthropic says the standard remains usable as is. It's worth validating with skills-ref, declaring dependencies in the compatibility field and trimming long descriptions.

What's the difference between a skill and MCP? MCP exposes tools and data to the agent through a protocol. A skill teaches the agent to execute a process, possibly using those tools. For the protocol side, the post on what MCP is covers the architecture.

Conclusion

Anthropic repeated with Agent Skills the move that made MCP a standard: it took the format out of its house and handed it to a neutral foundation, with Google and OpenAI maintainers at the table.

For anyone already writing SKILL.md files, the immediate change is small. The medium-term change is big. Your skills folder stops being Claude Code config and becomes a portable team asset.

As long as you separate process from harness.

If you're still building the foundation, the post on hooks, slash commands and MCPs covers the other harness pieces where skills fit in.