---
title: "Baseline Skill · concept · Agentic Atlas"
description: "Baseline Skill: the simplest complete skill, and the starting shape later skill patterns build on."
canonical: "https://agentic-atlas.dev/nodes/baseline-skill"
last-updated: "2026-09-23"
---

1. [Agentic Atlas](https://agentic-atlas.dev/)
2. [Patterns in the Agentic Atlas](https://agentic-atlas.dev/atlas)
3. [Foundations](https://agentic-atlas.dev/nodes/foundations)
4. Baseline Skill

Seen working in [Tell Me a Joke](https://agentic-atlas.dev/nodes/tell-me-a-joke).

1. concept
   # Baseline Skill
   **What does a complete agent skill need?**
   A complete skill needs only a name, a description saying when it fires, and a body.
   Hook
   the simplest complete skill, and the starting shape later skill patterns build on
   Laws & fences
   - Only the name and description stay loaded at all times, and the body loads only when triggered.
   - Keep the description lean and precise, because its cost is paid before any use.
   - Every skill costs a name slot, routing attention, and maintenance, whether or not it adds capability.
   - A body should add only what the model would not otherwise do, not re-teach what it knows.
   When to reach
   - Reach for this when starting a real skill, then add one deliberate change at a time.
   - Reach for this when you need a fixed base to measure a later change against.
   Provenance
   [baseline-skill/definition](https://agentic-atlas.dev/nodes/baseline-skill#definition) · v1.0.11
   Addresses
   atlas_cards baseline-skill
2. [Foundations](https://agentic-atlas.dev/nodes/foundations)
3. [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
4. [The Contract](https://agentic-atlas.dev/nodes/contract-documentation)
5. [Tell Me a Joke](https://agentic-atlas.dev/nodes/tell-me-a-joke)
6. [Statelessness](https://agentic-atlas.dev/nodes/statelessness)
7. [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch)
8. [The Session Bill](https://agentic-atlas.dev/nodes/session-bill)
9. field notes
   - “graded access composed from deferral and distillation”
   - “the altitude above the single skill (N skills, compounding costs)”
   - “partition a workflow into bounded responsibilities; realization may be code, tools, in-context modules, or child LLM executions”

The Session Bill +1 more unfold the map fold the map

The card, in place · its connections drawn edges from atlas_links baseline-skill

On this plate

[definition](https://agentic-atlas.dev/nodes/baseline-skill#definition) [why-it-matters](https://agentic-atlas.dev/nodes/baseline-skill#why-it-matters) [model-and-claims](https://agentic-atlas.dev/nodes/baseline-skill#model-and-claims) [scope-and-boundaries](https://agentic-atlas.dev/nodes/baseline-skill#scope-and-boundaries) [implications-the-consequence-map](https://agentic-atlas.dev/nodes/baseline-skill#implications-the-consequence-map) [evidence](https://agentic-atlas.dev/nodes/baseline-skill#evidence) [relationships](https://agentic-atlas.dev/nodes/baseline-skill#relationships) [lineage](https://agentic-atlas.dev/nodes/baseline-skill#lineage) [relationships-ledger](https://agentic-atlas.dev/nodes/baseline-skill#relationships-ledger)

Every section is addressable on its own. Read only the ground you need.

## Definition

[Permalink to Definition section](https://agentic-atlas.dev/nodes/baseline-skill#definition)

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: a literally-empty no-op is invisible in use — 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](https://agentic-atlas.dev/nodes/contract-documentation) — a typed link, not residence: that node governs inter-actor seams; the entry seam lives here with the skill's anatomy).
- 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.

## Why it matters

[Permalink to Why it matters section](https://agentic-atlas.dev/nodes/baseline-skill#why-it-matters)

Before you can reason about what a skill *does*, you need a fixed reference for what a real skill minimally *is*. Without that anchor, every structural move you make is described relative to nothing: **a diff needs its base** ([Foundations](https://agentic-atlas.dev/nodes/foundations) → the five-pillars map).

The wrong skill to start from is the useful one. A first skill that earns its keep carries the *task* and the *structure* at the same time, and you cannot tell them apart — you 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 move after it 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.

## Model and claims

[Permalink to Model and claims section](https://agentic-atlas.dev/nodes/baseline-skill#model-and-claims)

### Everything later is a structural diff against this artifact

The organizing claim (normative — it governs how skill designs are described and compared, not how the runtime behaves): 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](https://agentic-atlas.dev/nodes/statelessness)'s cost face) and priced as propagation scope at [The Context Economy](https://agentic-atlas.dev/nodes/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](https://agentic-atlas.dev/nodes/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.

## Scope and boundaries

[Permalink to Scope and boundaries section](https://agentic-atlas.dev/nodes/baseline-skill#scope-and-boundaries)

- **What skills buy at all is not this node's claim.** The addressability/replayability/discoverability/seam account lives at the [Foundations](https://agentic-atlas.dev/nodes/foundations); this node shows the shape that framing points at.
- **The unit of analysis is the workflow, not the skill.** The tree describes workflows ([GLOSSARY](https://agentic-atlas.dev/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](https://agentic-atlas.dev/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](https://agentic-atlas.dev/nodes/context-economy)'s.
- **Nobody ships the baseline.** You reach for it as the shape you start every real skill from, and as the base you diff later moves against — a floor, not a tool.

## Implications — the consequence map

[Permalink to Implications — the consequence map section](https://agentic-atlas.dev/nodes/baseline-skill#implications-the-consequence-map)

- **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.** A later move is argued 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.

## Evidence

[Permalink to Evidence section](https://agentic-atlas.dev/nodes/baseline-skill#evidence)

**Exemplar — [Tell Me a Joke](https://agentic-atlas.dev/nodes/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 [Tell Me a Joke](https://agentic-atlas.dev/nodes/tell-me-a-joke) — 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.

## Relationships

[Permalink to Relationships section](https://agentic-atlas.dev/nodes/baseline-skill#relationships)

- **Parent:** [Foundations](https://agentic-atlas.dev/nodes/foundations) — resident as the baseline artifact among the five pillars; the deep *why we build skills at all* lives at the root, pointed at this node.
- **[The Contract](https://agentic-atlas.dev/nodes/contract-documentation):** the description-as-trigger-contract is the first, quietest appearance of the seam [primitive](https://agentic-atlas.dev/glossary/primitive); the argument surface is the entry seam's input half (typed link — that node governs inter-actor seams).
- **[LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch):** the sibling primitive whose *Anatomy of a dispatch* owns what a caller packs into an invocation; this node owns the invocation surface a skill exposes.
- ***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](https://agentic-atlas.dev/glossary) → *Skill*, *Trigger contract* (both anchored to this node).

## Lineage

[Permalink to Lineage section](https://agentic-atlas.dev/nodes/baseline-skill#lineage)

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.

The relationships ledger

Evidence-bearing references

## Relationships

Every connection keeps the section where it was found. The map above orients; this ledger carries the evidence.

### Outbound references 19

1. in-slice · occurrence 1
   [The Contract](https://agentic-atlas.dev/nodes/contract-documentation)
   the agreement on an artifact's shape and use whenever one component hands it to another
   Evidence: [Definition](https://agentic-atlas.dev/nodes/baseline-skill#definition) · occurrence 1
2. in-slice · occurrence 1
   [Foundations](https://agentic-atlas.dev/nodes/foundations)
   the ideas every other pattern assumes, and the test for what belongs here
   Evidence: [Why it matters](https://agentic-atlas.dev/nodes/baseline-skill#why-it-matters) · occurrence 1
3. in-slice · occurrence 1
   [Statelessness](https://agentic-atlas.dev/nodes/statelessness)
   the model keeps nothing between calls, so every turn re-sends and re-reads everything
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/baseline-skill#model-and-claims) · occurrence 1
4. in-slice · occurrence 2
   [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
   what each piece of context costs, in quality, dollars, and latency, and who pays
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/baseline-skill#model-and-claims) · occurrence 2
5. undisclosed · occurrence 3
   Undisclosed relationship
   graded access composed from deferral and distillation
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/baseline-skill#model-and-claims) · occurrence 3
6. in-slice · occurrence 4
   [Foundations](https://agentic-atlas.dev/nodes/foundations)
   the ideas every other pattern assumes, and the test for what belongs here
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/baseline-skill#model-and-claims) · occurrence 4
7. undisclosed · occurrence 5
   Undisclosed relationship
   the altitude above the single skill (N skills, compounding costs)
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/baseline-skill#model-and-claims) · occurrence 5
8. in-slice · occurrence 1
   [Foundations](https://agentic-atlas.dev/nodes/foundations)
   the ideas every other pattern assumes, and the test for what belongs here
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/baseline-skill#scope-and-boundaries) · occurrence 1
9. undisclosed · occurrence 2
   Undisclosed relationship
   partition a workflow into bounded responsibilities; realization may be code, tools, in-context modules, or child LLM executions
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/baseline-skill#scope-and-boundaries) · occurrence 2
10. undisclosed · occurrence 3
    Undisclosed relationship
    graded access composed from deferral and distillation
    Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/baseline-skill#scope-and-boundaries) · occurrence 3
11. in-slice · occurrence 4
    [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
    what each piece of context costs, in quality, dollars, and latency, and who pays
    Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/baseline-skill#scope-and-boundaries) · occurrence 4
12. in-slice · occurrence 1
    [Tell Me a Joke](https://agentic-atlas.dev/nodes/tell-me-a-joke)
    a real runnable skill (the artifact *is* the example)
    Evidence: [Evidence](https://agentic-atlas.dev/nodes/baseline-skill#evidence) · occurrence 1
13. in-slice · occurrence 2
    [Tell Me a Joke](https://agentic-atlas.dev/nodes/tell-me-a-joke)
    a real runnable skill (the artifact *is* the example)
    Evidence: [Evidence](https://agentic-atlas.dev/nodes/baseline-skill#evidence) · occurrence 2
14. in-slice · occurrence 1
    [Foundations](https://agentic-atlas.dev/nodes/foundations)
    the ideas every other pattern assumes, and the test for what belongs here
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/baseline-skill#relationships) · occurrence 1
15. in-slice · occurrence 2
    [The Contract](https://agentic-atlas.dev/nodes/contract-documentation)
    the agreement on an artifact's shape and use whenever one component hands it to another
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/baseline-skill#relationships) · occurrence 2
16. in-slice · occurrence 3
    [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch)
    one LLM execution starting another, whether the parent waits, joins later, or never joins
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/baseline-skill#relationships) · occurrence 3
17. undisclosed · occurrence 4
    Undisclosed relationship
    graded access composed from deferral and distillation
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/baseline-skill#relationships) · occurrence 4
18. undisclosed · occurrence 5
    Undisclosed relationship
    partition a workflow into bounded responsibilities; realization may be code, tools, in-context modules, or child LLM executions
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/baseline-skill#relationships) · occurrence 5
19. undisclosed · occurrence 6
    Undisclosed relationship
    the altitude above the single skill (N skills, compounding costs)
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/baseline-skill#relationships) · occurrence 6

### Inbound references 5

1. in-slice · occurrence 3
   [The Context Economy](https://agentic-atlas.dev/nodes/context-economy#relationships)
   the simplest complete skill, and the starting shape later skill patterns build on
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-economy#relationships) · occurrence 3
2. in-slice · occurrence 2
   [Foundations](https://agentic-atlas.dev/nodes/foundations#model-and-claims)
   the simplest complete skill, and the starting shape later skill patterns build on
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/foundations#model-and-claims) · occurrence 2
3. in-slice · occurrence 4
   [Foundations](https://agentic-atlas.dev/nodes/foundations#model-and-claims)
   the simplest complete skill, and the starting shape later skill patterns build on
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/foundations#model-and-claims) · occurrence 4
4. in-slice · occurrence 1
   [Foundations](https://agentic-atlas.dev/nodes/foundations#relationships)
   the simplest complete skill, and the starting shape later skill patterns build on
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/foundations#relationships) · occurrence 1
5. in-slice · occurrence 2
   [The Session Bill](https://agentic-atlas.dev/nodes/session-bill#implementation-the-six-shifts)
   the simplest complete skill, and the starting shape later skill patterns build on
   Evidence: [Implementation](https://agentic-atlas.dev/nodes/session-bill#implementation-the-six-shifts) · occurrence 2

[↑ back to the top](https://agentic-atlas.dev/nodes/baseline-skill#content) [← the survey](https://agentic-atlas.dev/atlas)

Node baseline-skill · corpus 78c0e17 · Catalog revision e0cb75881244b1a82193ca738b82a0d508dd62e822524ae82873ec79d51dbb61