Skills as Composable Units

Your expertise has a shape. Now there's a container for it.

You've solved problems worth keeping. Prompts that work reliably. Context that helps agents understand your domain. Approaches that succeed where generic instructions fail. You've figured things out.

But where does that knowledge live?

Scattered. Conversation histories you'd have to dig through. Project-specific files. Mental models you'd rebuild from scratch. Every new project starts over because the solutions aren't portable. The expertise becomes inaccessible the moment you close the session.

This is the tax on AI work nobody talks about: you get good at something, then lose it because it was never packaged to travel.

The Shape That Emerged

Three independent systems arrived at the same answer.

OpenClaw, the open-source agent framework, structures capabilities like this:

skill/
├── SKILL.md          # Instructions
├── references/       # Supporting files
└── package.json      # Metadata

Codex converged on the same pattern—markdown instructions plus supporting context plus package identity. Claude Code adopted a similar approach for its skills system.

No coordination. No committee. Three different teams facing the same problem discovered the same shape.

When that happens, you're not looking at opinion. You're looking at discovery. The structure emerged because it's what capabilities actually need to be portable.

What the Structure Reveals

The pattern has three parts, and each part does necessary work:

SKILL.md — Instructions The interface. What the skill does. How to invoke it. What to expect. Written in markdown because markdown is readable by humans and parseable by agents.

references/ — Context Supporting files the skill needs. Examples of good output. Templates. Domain-specific data. The context is what makes generic instructions specific.

package.json — Identity Name, version, dependencies. What this skill is called and how to find it. The metadata is what makes the skill addressable—discoverable, installable, composable with other skills.

Instructions, context, identity. That's not arbitrary. That's what any transferable capability requires. You need to know what to do (instructions), what to know (context), and what to call it (identity).

The pattern wasn't designed. It was found.

The Portability Principle

The skill format is platform-agnostic. That matters more than its elegance.

A skill written for OpenClaw works with Codex. Works with Claude Code. Works with any agent that can read markdown and access files. The investment doesn't lock you in—it travels.

This is the build-once-reuse-everywhere promise actually delivered. Create a skill that solves a problem, and that solution is portable across tools, across projects, across time. The format is simple enough that any agent can parse it. The structure is standard enough that you don't have to explain it.

The key properties:

• Markdown-first — Human-readable and agent-parseable
• Self-contained — Everything needed is in the package
• URL-installable — curl can bootstrap it
• Composable — Skills can reference other skills

That last property is what makes this compound. Skills aren't isolated. A skill can invoke other skills. Capabilities stack.

The Container for Expertise

You're not learning a new format. You're recognizing that your accumulated expertise has a natural packaging unit.

Think about what you've figured out in the last year of working with AI. The prompting patterns that work for your domain. The context files that help agents understand your codebase. The workflows that produce reliable results.

All of that has been locked in your head and your chat history—visible to you, but not portable. Not reusable. Not composable. Every time you start a new project, you reconstruct from memory what you've already learned.

The skill format is the extraction pipeline for expertise. It takes what you know and packages it so it travels.

The format doesn't add complexity. It makes explicit what was always implicit in how capabilities work. You already had instructions (the prompts you use), context (the files you reference), and identity (what you call this approach). The skill format just makes that structure explicit and portable.

The Practical Move

Every time you solve a problem with an agent, ask: could I package this?

Not everything needs packaging. But the approaches you use repeatedly, the context that helps agents perform well in your domain, the workflows that took iteration to get right—those are candidates.

The format is simple:

1. Write SKILL.md describing what the skill does and how to use it
2. Add a references/ folder with supporting files
3. Create package.json with name and version

That's it. You've created a portable capability. Next time you need this solution—in a different project, on a different machine, with a different agent—you have it.

The investment compounds. Each skill you create is a problem you never solve again. Each skill can reference other skills. The system compounds. Solve once, reuse forever.

The Standard Nobody Declared

This is how standards actually emerge. Not through committees and specifications, but through convergence. Enough people face the same problem, enough solutions appear, and the successful ones share common structure. The structure becomes the standard.

OpenClaw didn't copy Codex. Codex didn't copy OpenClaw. They both discovered what portable capabilities need to look like. That discovery is now available to everyone.

You don't have to wait for official adoption. You don't need permission. The format works today, with the tools you already use. Package your expertise. Make your solutions portable.

Your knowledge has a shape. The container exists. Everything you solve from here on out can travel with you.

Sources: Simon Willison on Codex skills pattern + OpenClaw skill format documentation + convergent evolution across agent ecosystems (January-February 2026)