Baseline Skill

A baseline skill is the envelope as identity: a named, triggerable, documented handle with nothing decomposed inside it. (Reframed from no-op skill, 2026-06-27 grilling: a literally-empty no-op is pedagogically invisible — you invoke it and nothing happens, so there is nothing to see. The baseline is the smallest skill that works, not the smallest that parses — the simplest skill someone would actually write, with nothing practiced beyond the wrapper.)

Four slots, one of them deliberately empty:

• a name — the namespace slot, the handle you invoke on purpose;
• a description — which does double duty: human-readable doc and the probabilistic trigger contract (it says when this fires);
• an argument surface (optional slot — the baseline leaves it empty) — invocation-time args are the entry seam's input contract: the description says when it fires, args say what it fires with. The user→skill analog of the contract anatomy's input half (The Contract — a typed link, not residence: that node governs inter-actor seams; the entry seam lives here with the skill's anatomy). (Residue of the cut "description is a router," relocated here 2026-07-05 when the dispatch-packing stub folded into LLM Dispatch.)
• a body — where behavior attaches; in the baseline it does its one trivial thing and no more.

Packaged form. In the Agent Skills packaging (the open standard at agentskills.io), the unit is a directory, its name the invocable handle. The SKILL.md inside has exactly two regions: YAML frontmatter carrying name and description — the only required fields — and the Markdown body below it. Everything else the frontmatter can declare (allowed tools, invocation control, a model or effort setting) is optional and earns its own pattern later; the baseline is name + description + body and nothing else.

Before you can teach what a skill does, you need a shared reference for what a real skill minimally is. Without that anchor, every later pattern is described relative to nothing — the residence argument in one line: a diff needs its base (Foundations → the five-pillars map).

The wrong opener is the useful first skill. A first skill that earns its keep teaches the task and the structure at the same time, and a learner cannot tell them apart — they copy the surface and miss the skeleton. The baseline forces the separation: nothing on the page but the envelope, so every structural decision is naked and arguable, and every later pattern reads as the same skeleton plus one deliberate addition.

The baseline also exposes the cost side. With no capability on the page, the only quantity left in view is the cost of merely existing — which is exactly the quantity a capable first skill hides.

Everything later is a structural diff against this artifact

The organizing claim (normative — it binds the corpus's own teaching, not the runtime): every skill-facing pattern in the tree is an edit to this one shape. Referenced files in the body, optional frontmatter, a second skill behind the boundary, an argument surface filled in — each family's move lands somewhere on the four slots. The baseline is what makes those moves visible as moves.

The description is the only always-resident part

Observation, and the mechanical fact the trigger contract stands on: the name + description load at startup and stay resident so the model can route; the body loads only when the skill fires. The always-resident line is re-shipped every call (Statelessness's cost face) and priced as propagation scope at The Context Economy; the graded-access pattern that generalizes the loading tiers is graded access composed from deferral and distillation, which names this exact three-tier skill shape as its canonical instance.

Three authoring consequences, each inherited by every later pattern:

• State what it does and when to use it. "Replies with a joke" is half a contract; "use when the user asks for a joke" is the half that triggers it.
• Write it in the third person. The description is injected verbatim into the routing surface; "I can tell jokes" reads as the agent's own voice (Anthropic's authoring guidance).
• Spend tokens on the description grudgingly, on the body freely. The description is a permanent resident; the body is paid for only on use.

A skill is never free — the trade at its smallest

A skill is a trade: addressability + replayability bought against a namespace slot, a line of routing attention, and a maintenance surface — paid whether or not it adds capability. The baseline must earn its slot. ("Tell me a joke" earns nothing structural: the model already tells jokes — which is exactly why it is the clean baseline and not a pattern worth shipping for real.) The full bought/paid enumeration is root material (Foundations → What a skill buys); this node holds the trade at N = 1, and the the altitude above the single skill (N skills, compounding costs) scales it to N slots compounding.

The body constrains; it does not re-explain

Heuristic, from the same authoring guidance: the default assumption is that the model is already very capable, so the only body content that earns its place is what the model wouldn't otherwise do. The baseline is the limiting case — a one-line body, because for a joke there is nothing the model wouldn't otherwise do. A body bloated with re-taught capability is strictly worse than the prompt it replaced: same tokens, plus the standing tax.

• What skills buy at all is not this node's claim. The addressability/replayability/discoverability/seam account lives at the Foundations; this node shows the shape that framing points at.
• The skill is not the corpus's unit of analysis. The tree describes workflows (GLOSSARY → Workflow, ADR 0007); a skill is one useful packaging and reuse surface, and this node is the on-ramp, not a bound on later claims.
• The bridge to composition: a baseline skill is the envelope as identity (the boundary merely exists, answering "why skills at all?"); drawing the line on purpose around something, to manage complexity, crosses into partition a workflow into bounded responsibilities; realization may be code, tools, in-context modules, or child LLM executions. No internals → still baseline. The moment a skill earns one line the model wouldn't otherwise do, it has left the baseline behind.
• The agent definition is deliberately excluded. The same shape — name + description + body — one altitude up defines a dispatchable actor (GLOSSARY → Agent definition); that is the heavy-agent story, not the baseline's.
• Loading mechanics are pointed at, not owned. The resident/deferred split is stated here only as far as the trigger contract needs it; the pattern is graded access composed from deferral and distillation's, the prices are The Context Economy's.
• Nobody ships the baseline. You reach for it as the curriculum's opening move and as the shape you start every real skill from — a floor, not a tool.

• Start from the baseline; add one deliberate constraint at a time. Every slot filled beyond the wrapper should be attributable to a named move — the authoring discipline the diff claim buys.
• Worked examples inherit the diff shape. A delta is only legible against a declared base, and the baseline is the declared base — this node's claim applied to proof: single-decision shifts, one per law, and never a cumulative punchline.
• The baseline is the zero point of measurement. Later patterns fill their proof obligations with before→after numbers; the baseline supplies the before — the cost of merely existing that every payoff is measured against, and no payoff of its own.
• Description discipline starts at N = 1. The always-resident line is the one part whose cost you pay before any use; writing it lean and precise is the first act of context engineering, before any pattern is applied.

Exemplar — Tell Me a Joke. A skill that wraps a capability the base model already has: it looks like it does something (you get a joke) yet contributes nothing structural — so there is genuinely nothing to encapsulate. That isolates the envelope from any encapsulation value, which is what makes it the cleanest possible baseline. The artifact is shipped, not described separately — the artifact is the example:

• a real, runnable skill (installable and demonstrable in Claude Code), not a toy mock — the fidelity test: write your own skill from scratch and it looks just like this;
• an honest, model-invocable trigger-contract description (what it does + when to fire);
• a one-line body: "Tell the user a short, clean joke.";
• non-meta — no "this is the baseline exemplar" commentary in the artifact; that commentary lives here in the write-up;
• it lives at examples/tell-me-a-joke/SKILL.md — the artifact-only example form, metadata in its own frontmatter (ADR 0011).

Grounding of the anatomy claims (verified against the live spec, agentskills.io/specification, 2026-08-02). The two-region shape, the two required fields, and the three-stage loading split (discovery / activation / execution) are the standard's own text. The caps are exact spec constraints, not approximations: name max 64 characters — and it must match the parent directory name, which is what makes the directory the unit and its name the handle; description max 1024 characters, non-empty. The ~100-token always-resident metadata figure is the spec's own published number (order-of-magnitude by its own tilde); the ratio (cheap always-on metadata, larger pay-on-trigger body — the spec recommends bodies under 5,000 tokens) is the claim that survives any re-measurement. If the packaging standard changes shape, the envelope-as-identity definition — name + description + body — survives it, because it is a claim about the slots, not the YAML.

• Parent: Foundations — resident as the baseline artifact among the five pillars; the deep why we build skills at all and the masterclass opener live at the root, pointed at this node.
• The Contract: the description-as-trigger-contract is the first, quietest appearance of the seam primitive; the argument surface is the entry seam's input half (typed link — that node governs inter-actor seams).
• LLM Dispatch: the sibling primitive whose Anatomy of a dispatch absorbed the packing half of the retired dispatch-packing stub; this node holds the invocation-surface residue.
• graded access composed from deferral and distillation: its canonical instance is the skill's three loading tiers; the baseline's description is tier 1 of that instance.
• partition a workflow into bounded responsibilities; realization may be code, tools, in-context modules, or child LLM executions: the far side of the identity/deliberate-boundary line drawn in Scope and boundaries.
• the altitude above the single skill (N skills, compounding costs): the trade at scale — "earn its slot" made an ongoing audit across N skills.
• Canonical definitions: GLOSSARY → Skill, Trigger contract (both anchored to this node).

The hello, world program (Kernighan, A Tutorial Introduction to the Language B, 1972; popularized by Kernighan & Ritchie, The C Programming Language, 1978): the smallest program that actually runs, taught for its envelope rather than its computation. The delta is that the envelope is no longer inert — the description is a live routing contract read on every call — so unlike hello.c the baseline goes on costing after it has run.