Agent Skills: The Standard 35 AI Tools Agreed On While You Weren't Looking

What Happened

Anthropic's `anthropics/skills` repository surged past 131,000 GitHub stars, but the star count is the least interesting part of this story. The repo is the reference implementation for Agent Skills, an open standard that has quietly assembled the broadest coalition in AI tooling: Cursor, GitHub Copilot, VS Code, OpenAI Codex, Google's Gemini CLI, JetBrains Junie, Mistral Vibe, Databricks Genie Code, Snowflake Cortex Code, and roughly 25 more platforms have all adopted the format.

The spec lives at agentskills.io and defines something deliberately simple: a folder containing a `SKILL.md` file with YAML frontmatter (`name` and `description`) plus markdown instructions. Skills can optionally bundle scripts, reference materials, and templates. That's it. No SDK, no runtime, no protocol negotiation.

A standard this simple getting adopted by both OpenAI Codex and Anthropic's Claude Code — direct competitors — signals that the industry has decided agent-level interoperability matters more than platform lock-in.

Why It Matters

### The MCP Complement, Not Competitor

Developers who've been tracking Anthropic's Model Context Protocol (MCP) might wonder how Skills fit in. The distinction is clean: MCP standardizes *what tools an agent can access* (APIs, databases, file systems). Agent Skills standardize *how an agent should perform a task* — the procedural knowledge, the step-by-step workflow, the domain-specific judgment calls.

Think of it this way: MCP tells an agent "you can query this database." A Skill tells it "when reviewing a pull request for our payments service, check the migration files first, verify idempotency keys are present, and flag any direct SQL that bypasses the ORM."

Skills are where your team's tribal knowledge becomes machine-readable. The senior engineer who knows all the deployment gotchas? That's a skill. The design system conventions that only three people remember? Skill. The compliance checklist that lives in a Google Doc nobody reads? Skill.

### Progressive Disclosure Solves the Context Problem

The spec's most technically interesting decision is its three-stage loading model. At startup, an agent reads only the `name` and `description` fields from each available skill — a few tokens per skill. When a user's task matches a skill's description, the agent loads the full `SKILL.md` instructions. During execution, it optionally loads bundled scripts and reference files.

This matters because context windows are expensive and finite. An agent can have hundreds of skills available while consuming almost zero context until one is actually needed. It's the same lazy-loading principle we use everywhere in software, applied to LLM context management.

### The Adoption List Is the Story

Let's be specific about who's on board. The agentskills.io client showcase includes:

- IDE agents: Cursor, VS Code (Copilot), JetBrains Junie, TRAE (ByteDance), Kiro (AWS) - CLI agents: Claude Code, OpenAI Codex, Gemini CLI, Mistral Vibe, Goose (Block), Roo Code - Platform agents: Databricks Genie Code, Snowflake Cortex Code, Factory, OpenHands - Frameworks: Spring AI, Laravel Boost, Letta, fast-agent

That's not a list of Anthropic partners. That's a list of competitors who independently decided this format was worth supporting. When Google, Microsoft, OpenAI, and Anthropic all implement the same spec without a formal standards body forcing them to, you're looking at a de facto standard, not a proposal.

What This Means for Your Stack

### Start Writing Skills Now

If you're using any of the 35+ compatible agents, you can start packaging your team's knowledge today. The format is version-control friendly (it's just files), requires no build step, and works immediately:

``` my-team-skills/ ├── deploy-checklist/ │ └── SKILL.md ├── code-review-standards/ │ ├── SKILL.md │ └── references/style-guide.md └── incident-response/ ├── SKILL.md └── scripts/check-runbook.sh ```

The `anthropics/skills` repo includes production-grade examples: document creation skills for Word, PDF, PowerPoint, and Excel that demonstrate patterns for complex, multi-step workflows. These are the actual skills powering Claude's document capabilities, released as source-available reference implementations.

### Portability Is Real

The practical implication: a skill you write for Claude Code today works in Cursor, Copilot, Codex, or Gemini CLI without modification. If your team switches agents next quarter — and given how fast this market moves, that's not hypothetical — your accumulated workflow knowledge migrates with you. This is a meaningful reduction in switching costs that benefits developers, not vendors.

### Watch the Ecosystem, Not the Repo

The 131K stars on the GitHub repo are a vanity metric. What matters is the skill marketplace that's forming around the standard. Notion has already published official Notion Skills for Claude. Laravel shipped `laravel/boost` with agent skills baked in. Spring AI integrated skills support. The interesting question isn't whether the format wins — it already has — but how quickly third-party skill libraries emerge for common workflows: CI/CD pipelines, infrastructure-as-code patterns, security review checklists, compliance frameworks.

Looking Ahead

Agent Skills represent something we don't see often in AI: competing companies agreeing on a format before the market consolidates. The standard was originally developed by Anthropic, released openly, and adopted without the usual standards-body overhead. The risk is fragmentation — vendors extending the spec with proprietary features that break portability. But with this many implementers already shipping, the gravity is toward convergence. For practitioners, the move is straightforward: start encoding your team's hard-won knowledge as skills, commit them alongside your code, and treat them as first-class infrastructure. The agents are ready. The question is whether your workflows are.