Appearance
Metaskills are the composition layer above agents — one skill file reused across N agents plus an updatable mental model that turns stateless agents into specialists whose expertise compounds session-over-session.
Guide
How to Build Metaskills
Start here
Metaskills are disciplines, not spawners.
not this
Skills that spawn skills
Rare, under-documented, mostly imaginary. If you came here looking for runtime skill synthesis, that's not what this layer is about — and chasing it is how you end up with an unmaintainable meta-tower.
this
Composition disciplines
One skill file shared across many agents. Per-agent mental models that update after tasks. The layer where stateless agents turn into specialists — because what they know persists across sessions.
Skip this framing and you'll build the wrong thing. Metaskills are how skills scale across agents and time — not how skills invent themselves.
Reading path
Five nodes, in order. Each answers the next's "why."
Read top to bottom. The principle justifies the pattern; the pattern enables the primitive.
01
Specialization Compounds
The principle. An agent that reads and updates its own mental model across sessions outperforms a stateless generalist — every cold session is learning lost. This is why the metaskill layer is worth its overhead.
02
Skill Composition
The pattern. Reusable behavioral-rule files declared in agent frontmatter. One file, N agents. Static composition beats runtime for almost every case you'll meet.
03
Progressive Disclosure
The sizing rule. Keep top-level skill files lean — load detail only when the agent hits the branch that needs it. Without it, skills drift into monolithic reference docs nobody reads fully.
04
Skill
The artifact. A markdown file encapsulating one reusable behavioral rule. Target 30–60 lines — short enough to compose freely, long enough to carry substantive guidance.
05
Mental Model
The mechanism. Per-agent updatable knowledge file. Bounded (line budget), updatable (agent appends after tasks), domain-owned (one role per file). This is what operationalizes Specialization Compounds.
Each node answers why the next one exists. Read them out of order and the logic breaks.
What each node teaches
Five destinations. One takeaway each.
PrincipleSpecialization Compounds
Stateless agents reset. Stateful ones accrue. The second kind wins over any meaningful timeline.
Takeaway: if your agents aren't writing back what they learn, you're paying for amnesia.
PatternSkill Composition
Pull shared rules out of agent files. Any rule that applies to ≥2 agents becomes a skill referenced by frontmatter.
Takeaway: fix once; every agent inherits at next boot.
PatternProgressive Disclosure
A skill file is a lean entry point, not a reference doc. Deep detail lives behind links, loaded only when needed.
Takeaway: if your skill is >100 lines, you're doing two things.
PrimitiveSkill
Frontmatter plus imperative body. 30–60 lines. Declares when to apply; body is the prompt text inlined at boot.
Takeaway: one rule per file, phrased as a command.
PrimitiveMental Model
Dense YAML, ten sections, 1000-line cap. Read at task start; self-improved after changes. Cited claims only.
Takeaway: what remembers for the agent so it can forget everything else.
Three kinds of node: principle (why), pattern (shape), primitive (what to write). You need all three to build the layer.
Which node first?
Depends on what you're already missing.
Your agents already use shared skills — but does each agent remember anything between sessions?
IF NO
start with
Specialization Compounds
You're leaking learning every session. Read the principle, then jump to the Mental Model primitive to operationalize it.
IF YES, BUT…
rules are duplicated across agents
Skill Composition
Mental models exist but shared rules are inlined per-agent. Extract them to the skill library before the N-th copy silently diverges.
IF YES, BUT…
skills have become monoliths
Progressive Disclosure
Your skill files are pushing past 100 lines. Split the branch-specific depth out; keep the top-level imperative lean.
IF YES, AND…
you're authoring a new one
Skill
Go straight to the primitive — the anatomy tells you what frontmatter keys matter and how to phrase the body.
The guide is a menu, not a cathedral. Enter where the pain is. The other nodes wait patiently.
Adjacent guides
Where to go when metaskills aren't enough.
→
how-to-build-metaagents
Skills are what agents carry. Metaagents orchestrate the agents that use them — read next when you need coordination, not just composition.
→
how-to-author-templates
A skill file has a template shape of its own — frontmatter plus imperative rules. Read if you're drafting the template, not just using it.
This guide ends where orchestration and authoring mechanics begin. Don't over-read here.
The discipline
Metaskills are how specialization scales — across agents via one file, across sessions via one mental model.
Not skills-that-spawn-skills. Composition plus continuity. Fix once and every agent inherits; finish a task and the expertise file grows. Stateless becomes stateful. Generalist becomes specialist.