Appendix E — How to Write a Skill
Modeling a domain for an agent
Skills can play three broad roles. A tool-skill teaches an agent how to use a particular capability or interface. A process-skill packages a recurring procedure so that the agent can carry it out consistently rather than reconstructing the workflow each time. A mastery-skill packages reusable expertise for work that continues to require substantial judgment.
These categories describe a skill's primary role, not its format. A process-skill may contain steps that require judgment, and a mastery-skill may prescribe procedures. The distinction is where the reusable value principally lies: using a capability, carrying out a process, or exercising domain judgment.
This appendix focuses on process- and mastery-skills. Tool-skills matter too, but their details are more closely tied to the capabilities and interfaces exposed by a particular harness. The mechanisms by which agents discover and invoke tools continue to evolve — from command-line wrappers and vendor-specific interfaces to MCP and whatever follows them. Current platform documentation is therefore the right source for those mechanics.
Process and mastery raise a more durable engineering problem. Much engineering knowledge begins in an inconvenient form: an experienced engineer knows how work is done or how to judge what should be done. That knowledge may be scattered across conventions, examples, repeated instructions, documentation, and experience. Giving an agent more instructions does not necessarily give it a coherent process or way of reasoning.
Nor must such knowledge ultimately live in a skill. Learning can develop all three capabilities. Reinforcement learning, for example, can improve how an agent uses tools, carries out recurring processes, and exercises judgment when the training environment supplies useful feedback about those behaviors. A model trained extensively against a particular engineering environment could therefore internalize knowledge that otherwise might have been supplied through a tool-, process-, or mastery-skill.
The practical problem is that a general foundation model was not trained specifically for your engineering environment or your standards for good engineering. It does not automatically contain your current architecture, models, tools, procedures, obligations, failure history, tradeoffs, or standards for acceptable work. Those facts may also change much faster than the foundation model. Fine-tuning or reinforcement learning can move some of this knowledge into model behavior, but doing so requires examples, evaluators, rewards, or other feedback that expresses what successful behavior means in that environment.
Skills provide another engineering option: make the relevant knowledge explicit outside the model weights. A process-skill can make a recurring way of working explicit; a mastery-skill can make reusable distinctions and judgment explicit. Both can be inspected, revised, versioned, and supplied to different models without retraining them. This is Modeling in miniature: make engineering knowledge explicit so the agent does not have to reconstruct it.
Skills remain soft mechanisms. They can improve how an agent works and guide the choices it makes; they cannot guarantee that the agent follows that guidance. Learned behavior has the same basic limitation: increasing the probability of acceptable behavior is different from independently enforcing an engineering obligation. Where a property must hold, encode it in Alignment through constraints, types, validators, gates, or other mechanisms that do not depend on the producing agent choosing correctly.
The three skills introduced earlier in the book provide worked examples of the distinction. self-communicate and self-governance are mastery-skills: they package reusable expertise for domains in which the agent must continue to exercise substantial judgment. self-operate is a process-skill: it packages the recurring operational lifecycles through which the engineered environment is run. Together they also show why the boundary is not absolute: a process can contain judgment, and mastery can prescribe procedures.
Chapter 1 gives the construction methods and quality bar; Chapter 2 applies them to the three skills. By the end, you should be able to distinguish tool-, process-, and mastery-skills; recognize when each is appropriate; and package recurring engineering procedure or judgment so that an agent can inherit it rather than reconstruct it.