Reliable Business Workflows Through Skills

Use a skill to scaffold an AI agent for repeatable business work.

Where Workshop 1 left off

Last time, a Skill was something you typed: an SOP plus a trigger, calling tools someone else already built. That gets you a morning briefing. For complex, high-stakes, client-facing work, a skill needs more than SOP instructions.

The analogy holds: you’re asking an amnesiac to produce an output, say a contract. Beyond what’s in the session, it knows nothing about your business — your services, your pricing, your house style. Give it no source material and it will re-invent the contract from scratch, wrong in ways you won’t catch until it’s too late. A reliable output needs two things: content for the amnesiac to copy from, and a process structured so it can’t make things up on its own.

Instructions + References + Generator + Gates

Who this is for

You already use AI tools and want them to do real business work.
You’re still a normie. You don’t need to be a programmer, just comfortable letting Claude write a couple of scripts you’ll reuse.

Why do we care? AI models confidently make things up. At the model level, they’re just token-predictors. Reliable output means giving the model the right reference material and putting guardrails around the parts it would otherwise invent.

The path

The
Artifact

Anatomy of
a Skill

★

How AI
Guesses

Example Output

A service contract generated by a skill.

Process before tools — you’ll hear me say this a lot. If you don’t already have a reliable process (one several people could follow independently and get the same acceptable result), AI tools won’t solve your problem. If anything, AI is brilliant at disguising operational debt behind sensible-looking output that’s full of silent errors. So before you build a reliable skill, you need a reliable process. Don’t have one? Stop here and fix that first.

Demo: we switch to a live Claude Code session and watch this skill build a contract from scratch. Then we’ll take it apart.

Anatomy of Reliability

Every part exists to defeat a specific way AI gets things wrong.

A reliable skill is a set of parts, each taking a risky job away from the model. We still lean on the model’s intelligence to orchestrate the work, and we steer it in plain language (words like “cardinal rule” and “confirmation gate”) bundled with the reference files and scripts it runs through tool use. By the time the model is generating, every instruction and reference it needs is right where it’s working. The process is still non-deterministic, but the in-prompt guardrails keep fabrication to a minimum.

1 Verbatim references Source-of-truth files the model copies, never composes.
references/boilerplate.md · term/variant_b.md
Defeats: Fabricated legal text. The high-stakes language is lifted word-for-word, so the model never paraphrases a clause into something subtly wrong.
2 The Cardinal Rule No silent defaults — any unsourced value is bracketed and highlighted.
[CONFIRM: notice period]
Defeats: Invented numbers and dates. A value the skill can’t source becomes a visible yellow placeholder you can’t miss on review.
3 A deterministic generator A real script renders the document; the model only assembles a spec.
python3 generate_contract.py spec.json out.docx
Defeats: Formatting drift and math errors. The numbers and the layout are handled by code that runs the same way every time, instead of being improvised on each pass.
4 Structured input Forms capture client data instead of free-text chat.
show_widget(client_info.html)
Defeats: Transcription errors. The user fills typed fields and clicks Done; the data arrives shaped, not parsed back out of a sentence.
5 A load policy Read references on demand; never load the generator or the tests.
NEVER read at runtime: generate_contract.py
Defeats: A cluttered, distracted model. Only what’s needed for the current step enters context, so attention stays on the task. (Same idea as a well-paced lesson.)
6 Confirmation gates Explicit human checkpoints before anything expensive or irreversible.
Explicitly ask which Term variant — never default.
Defeats: Silent wrong assumptions. The skill stops and asks at the decisions that matter, instead of barreling ahead on a plausible-but-wrong default.

How AI Guesses (one token at a time)

A model never writes a sentence. It writes one token, re-reads everything, and samples the next from a distribution of guesses. Watch it draft a contract clause.

Either party may terminate this Agreement upon▮

Next-token distribution

Temperature 0.8 balanced focusedrandom

So that’s the engine. The model wrote a legal clause one sampled token at a time. Most were near-certain: grammar pins “days” and “notice” in place, the distribution spikes, and sampling barely matters. But the one token that costs money, the notice period, was a coin-flip with nothing in the prompt to anchor it. Run it again: the number changes. That’s not a bug to patch. It’s how the thing works. A reliable skill gives the model less to gamble on: the real number is copied verbatim from a reference, or a rule flags it as [CONFIRM:…] rather than letting the model sample a value. And temperature is the dial. Everything here gets riskier as you turn it up. At high temperature, even that safety rule can get out-sampled, and the model writes a guess where it should have stopped. So temperature isn’t really a creativity setting; it’s a reliability setting. That’s why production systems run cold, and why the dependable version backs the in-prompt rule with a deterministic check outside the model, so an unsourced value can’t ship however the sampling lands.