4.5 Packaging the Method as Skills

Some recurring engineering knowledge should be enforced by the environment. Other knowledge properly remains available to the reasoner. That knowledge can still become engineering capital: package the representations, examples, heuristics, decision procedures, and tools that improve recurring judgment so that later work inherits them rather than reconstructing them from a generic prior.

A skill is one such package. It can range from a compact procedure resembling a disciplined prompt to a substantial body of explicit domain knowledge with structured representations, examples, correctness conditions, retrieval, and executable tools. The relevant distinction is not how elaborate the package is, but what it lets a fresh agent inherit. A useful skill gives the agent some of the abstractions, distinctions, evidence, and practices that an experienced practitioner would otherwise have to reconstruct or supply interactively.

Packaging does not itself enforce anything. Prose, examples, models, and decision procedures can make a satisfactory decision substantially more likely while leaving the decision probabilistic. The same skill can also invoke enforcing mechanisms or carry the models and correctness conditions those mechanisms consume. Where an obligation should not depend on the agent's reasoning, the environment still needs a constraint, validator, gate, permission, or other mechanism that can act on that obligation independently.

Three roles recur. A tool-skill teaches how to use a particular capability or interface. A process-skill preserves a recurring way of working — a procedure with its states and decision points. A mastery-skill preserves a way of reasoning — domain representations, distinctions, correctness conditions, and a repeatable decision procedure for doing a class of work well. The companion repository demonstrates these through self-communicate and self-governance (mastery-skills) and self-operate (a process-skill).

A skill is therefore not confined to one side of the improve-judgment / enforce-obligations division. Its direct instructions may support a reasoner's judgment, but it can also carry or invoke the machinery through which selected obligations are enforced.

Recent industry examples show related packaging moves.^** Atlassian's Jira team reports a related move: it delegates keep-the-lights-on work — flaky tests, feature-flag cleanup, vulnerabilities, accessibility — by turning each into an explicit work item that carries context plus workflow instructions, so a maintenance class becomes delegable once the tacit repair procedure is encoded, not because the agent got clever ²2. Atlassian, “AI Agents for Jira Engineering Maintenance,” Atlassian, 2026, https://www.atlassian.com/blog/development/ai-agents-jira-engineering-maintenance.. Twilio's public account is sharp: an unguided agent asked to "verify users" hand-rolls a six-digit one-time password, while its skill redirects to a dedicated verification product and inherits rate limiting, fraud controls, and routing the operator never thought to request ¹1. Twilio, “Why Connect Twilio AI Skills,” Twilio, 2026, https://www.twilio.com/en-us/blog/developers/best-practices/why-connect-twilio-ai-skills.. The encoded procedure is the capital; the class of work becomes inheritable.

4.5.1 What a Reusable Skill Needs

A reusable skill needs three things: the representations needed to reason about the work, the recurring decisions that matter within it, and a procedure for making those decisions. The representations preserve the distinctions needed for this class of work; the recurring decisions capture the alternatives, failure modes, and tradeoffs that repeatedly matter; and the procedure determines when to invoke that knowledge, what tools or evidence to use, and what result to produce. The point is not the particular file format or vocabulary. It is to turn tacit practice into a bounded reasoning environment that a fresh agent can enter repeatedly. Figure 4.5-1 draws the shape.

The resulting package can be small or substantial. Some skills need only a few distinctions, examples, and a procedure; others need explicit models, examples and counterexamples, correctness conditions, retrieval rules, or executable tools for obtaining and checking evidence. Package the smallest substrate that reliably lets later agents inherit the relevant expertise rather than rediscover it.

4.5.2 Deliver the Right Context—and Measure It

Packaging knowledge solves only half the problem. The agent must also receive that knowledge when it matters. Loading everything all the time is the obvious solution, and often a bad one: every rule, model, example, procedure, and failure lesson competes for attention, so a larger context can make navigation harder rather than easier. The alternative is to separate what must remain continuously salient from what can be retrieved when the task makes it relevant.

Dynamic Context Injection (DCI) is one implementation of that pattern. The environment observes something about the current task, work surface, or lifecycle state; selects relevant engineering knowledge; and places that slice into the agent's working context. The standing context therefore carries the small amount of knowledge that should remain continuously available, while task-specific models, rules, examples, or procedures arrive when triggered by the work. The general pattern is shown in Figure 4.5-2.

Standing context should contain the mission, compact method, and the few policies whose salience must survive every task. Retrieve richer model slices, procedures, examples, and local constraints according to the work. Where relevance can be determined mechanically, inject the appropriate slice rather than relying on the actor to discover and retrieve it.

But context has a cost. More guidance is not automatically better guidance. It consumes tokens, attention, and reasoning capacity, and stale guidance can actively misdirect work.

So treat context delivery as an engineering intervention and measure its effect. Its value may be probabilistic but is still empirical: compare realized performance with and without the added knowledge. A prompt, example set, model, or skill earns its carrying cost when supplying it makes satisfactory outcomes more likely or cheaper to obtain. Task success comes first; token counts, retrieval hit rates, and similar measures help explain why. A context mechanism that consumes more reasoning budget without improving the engineering outcome has not earned its place.

The model-based software-engineering pilot is one example: run the same task against different model-and-context conditions and reasoner classes, and ask whether the supplied representation actually changes navigation cost or task success. What is portable is the discipline of testing whether engineered context does what we claim it does. Part V carries that pilot with its data and its limitations.

Context delivery changes what the reasoner can see; by itself, it does not change what the environment permits. A richer slice of the right rules makes a good action easier to find; only a constraint, validator, or gate makes a bad action unavailable.

4.5.3 Self-Governance: Engineering the Environment

Self-governance packages the MAGE method itself. It helps an agent ask the recurring questions: What should be represented? Does the representation still correspond to the system? What evidence exists? What deserves enforcement? How should a new mechanism be introduced? Has existing structure stopped earning its upkeep? The skill does not contain the system's concrete engineering knowledge; it teaches the agent how to reason about that knowledge. Models and tools in the governed environment supply the system-specific facts.

PRACTICE

Inset — MAGE Can Help Build Its Own Environment

The MAGE method can itself be packaged as a skill. The companion self-governance skill gives an agent the recurring concepts and procedures developed in this book: identify the relevant models, state the obligation, distinguish guidance from enforcement, locate the boundary where evidence becomes available, choose an appropriate mechanism, and preserve useful structure as engineering capital. Models and tools in the governed environment supply the system-specific facts.

This creates a useful division of expertise. A practitioner can work with the agent in the language of the domain: this must hold; this evidence matters; this decision remains subjective; this failure keeps recurring. The skill supplies a procedure for translating those statements into candidate models, guidance, and controls. Commodity coding intelligence can then realize that structure using the mechanisms available in the environment: schemas and types, constrained interfaces, static analyses, hooks, permissions, validators, admission gates, provenance, telemetry, or other machinery.

The division is particularly useful when the practitioner is not a software engineer. An accountant need not know in advance that a recurring obligation is naturally represented by a schema constraint followed by a workflow gate. A scientist can identify the provenance that must accompany an observation without knowing how to implement the repository hook that checks it. The agent can supply much of the implementation knowledge. The domain expert remains responsible for the correspondence claim: whether the resulting representation or mechanism captures the intended obligation.

That translation does not establish its own correctness. Agent-generated machinery requires evidence appropriate to its consequence, just as other generated artifacts do. Nor should every judgment become machinery. The same procedure may identify better context, a mastery skill, an experiment, or human review as the appropriate intervention when stronger enforcement is not feasible.

Figure 4.5-3 traces this division of expertise.

See Appendix E for the self-governance skill.

Where useful, the skill queries the environment's governance catalogue of existing mechanisms — a model of the method, not a catalogue of preferred controls.

The project's boot context can preserve mission, method, and concise rules, but treat those rules accurately. Mission orients. Method teaches judgment. Rules state project policy. They take effect only where an environmental mechanism enforces them. A numbered sentence in an always-loaded file is still guidance unless something outside the producing agent enforces it.

Underneath the method sit the operating rules the skill applies on every touch, the same set the companion skill carries:

Self-governance — operating rules

• Model before guessing. Reach concrete system knowledge through a provider; do not reconstruct it from memory or raise confidence by rhetoric.
• Ask what should become machinery. At every failure, ask whether the lesson is durable — and default to nothing.
• Method before tool. Choose the move the situation calls for, then the capability that performs it.
• Right-size the fix. Prefer the smallest sound change that closes the class; propose a larger intervention rather than installing it reflexively. Prefer prevention where the legitimate action space can honestly be narrowed.
• Escalate a genuine judgment, not an inconvenience. A real authority-or-consequence boundary earns a prepared decision handed upward; a merely hard problem does not.

A skill on its own is passive: it sits and waits to be invoked, and an agent heads-down in the work will not stop to invoke it. A hook brings the skill into the work while the evidence is still fresh enough to diagnose the episode; the skill applies the MAGE procedure to the episode and surfaces the relevant design forks — "we keep hitting this; here are two ideas, which should I try?" — then waits. It may recommend changing a model, an obligation, evidence, a mechanism, or nothing at all. The engineer retains the judgment about what matters enough to preserve.

Governance must earn its carrying cost

Governance mechanisms and other durable engineering assets can become capital when their continuing value exceeds their carrying cost; they can also depreciate. Over-investment turns governance maintenance into its own recurring cost. Three symptoms say the return has gone negative: upkeep crowds out product work; the checks cry wolf, flagging more than they catch; or the guarded failure is both cheap and rare. Each is a control whose upkeep outweighs its benefit. Size it the way Migrating to MAGE sizes any control — against the cost and the frequency of the failure it prevents — and retire the assets that no longer earn their cost.

Even a soft mechanism can be governed like a hard one. NVIDIA's public account describes treating a skill as a deployable capability rather than a static prompt, run through an eight-stage supply chain — source, review, scan, evaluate, skill card, sign, catalog, sync — where scanning looks for agent-specific threats (hidden instructions, trigger abuse, excessive agency, tool poisoning, purpose/access mismatch), not only conventional software risk ³3. NVIDIA, “NVIDIA Verified Agent Skills Provide Capability Governance for AI Agents,” NVIDIA, 2026, https://developer.nvidia.com/blog/nvidia-verified-agent-skills-provide-capability-governance-for-ai-agents/.. The prose is a reusable knowledge asset; the signing and gating around it add enforcement to its distribution and use.

4.5.4 Self-Operate: Running the Environment

Self-operate packages the operating loop of the previous chapter. It helps an agent identify the current lifecycle state, retrieve the sanctioned reaction, and execute, delegate, or escalate each step according to who or what can honestly decide it. It does not redesign the environment. When operation exposes a deficiency in a model, mechanism, skill, or lifecycle, self-operate returns that engineering problem — with evidence — to self-governance.

The skill is useful because operating procedure otherwise has to be reconstructed at every fresh session. It does not replace the underlying tools, state machines, validators, or gates. It makes their use repeatable.

Self-governance and self-operate package two different kinds of reusable engineering knowledge. Self-governance is a mastery-skill; self-operate is a process-skill. Table 4.5-1 sets the split side by side.

Neither absorbs the other: self-governance decides how a mechanism should exist; self-operate uses it at runtime.

4.5.5 Self-Communicate: a Boundary Test

Self-communicate provides a useful boundary test because technical communication remains substantially qualitative. There is no deterministic oracle for whether an explanation is clear, whether a figure exposes the right structure, or whether a presentation gives its audience the right progression of ideas. Yet those judgments are not structureless. Audience, purpose, information hierarchy, evidence, visual form, examples, and revision criteria can be represented, and a procedure can tell the agent how to reason about them. Packaging that knowledge improves the judgment without pretending to make "good communication" deterministic.

Deterministic and probabilistic controls can coexist with that qualitative procedure. Tools can check file validity, accessibility properties, required metadata, or other mechanically decidable obligations; evaluators can assess narrower qualitative properties where their error characteristics make that useful; the agent can continue to exercise judgment over narrative and presentation. As those judgments become better understood, additional obligations may become feasible to enforce. Self-communicate therefore exercises the same pattern as the rest of MAGE: improve the substrate for judgment, enforce selected obligations where feasible, and leave the remaining degrees of freedom open.

Self-communicate is not a third pillar of MAGE. It demonstrates that the packaging pattern can extend beyond governance and operations. Appendix E distinguishes tool-, process-, and mastery-skills and gives construction methods for process- and mastery-skills.

Reusable agent procedures can become engineering capital when later work inherits them, and the industry is finding the pattern in parallel. Part V's MAGE in the Wild sets six such systems side by side.