SKILL 18 / WRITING · DEEP DIVE

Examples Over Rules: The Recipe Behind Writing Skills

Three pairs beat ten rules · 1–3 pairs per rule, and 3 is the ceiling · plus: the official directory named examples/ contains no examples

2026-09-19 · BigCat

"Write it more concisely" is a rule. It has a value in your head and no value at all in the model's. The examples pattern fixes exactly that: stop describing the standard, paste both endpoints of it instead. This issue takes apart four artifacts you can open and counts them — including a countable answer to how many example pairs one rule deserves.

Prerequisite → Skill 17 · De-Slopping Skills (most of this issue's example artifacts come from those lists)

// WHY THIS MATTERS

One disclosure first. The roadmap named the "example sections" inside the official brand-guidelines and doc-coauthoring skills as this issue's template. I pulled both and read them line by line: brand-guidelines is 73 lines and contains zero examples; doc-coauthoring is 375 lines and its examples are written for the human, teaching you how to reply — not model-facing sample prose. So the template isn't in those two. It's in the "Examples pattern" section of the official best-practices doc, and in two community skills you can open. And that gap is this issue's first criterion: not every skill should have examples. Every line count and pair count below was counted today from the main branch, not copied from an aggregator.

// 01

What it kills for you: giving adjectives a value

The claim: examples don't replace writing rules. They cure a specific disease — adjectives with no assigned value. "Concise," "punchy," "no marketing voice" resolve differently in your head than in the model's, and one before/after pair pins the range down on paper.

Copy this one section and you can start: the "Examples pattern" in the official Skill authoring best practices is a complete template. The subject is commit messages, there are exactly three pairs, the form is Input: one line of natural-language description and Output: a code block, and it closes with a single line: "Follow this style: type(scope): brief description, then detailed explanation." The section's own conclusion reads:

Examples convey the desired style and level of detail to Claude
more clearly than descriptions alone.

(Per platform.claude.com, that page, 2026-09.) What it kills is a requirement like "write a good commit message" that nobody can accept or reject. Paste three comparable artifacts and the acceptance criterion is sitting right there.

How to use it

The official skill-creator (anthropics/skills · skill-creator) carries a condensed version of the same section you can copy structurally. It adds one warning: "if 'Input' and 'Output' are in the examples you might want to deviate a little" — don't leave those two literals in the shipped skill, or the model learns the labels along with the style.

The first thing you can actually run: open a piece you recently had to rewrite after it was sent back. The original goes in Before, the accepted version goes in After, and you add one line for what changed. One pair is enough to start; you don't need three. A real rejected draft beats an invented example, for reasons in section 03.
Further reading · Anthropic · Skill authoring best practices (the "Common patterns" chapter puts Template pattern, Examples pattern and Conditional workflow pattern side by side, 2026-09)
// 02

Mechanism: rules name the forbidden zone, examples draw its border

The claim: rules and examples aren't an either/or. blader/humanizer welds them into a four-slot unit, and that unit is the single most copyable thing in this issue.

The four-slot unit · blader/humanizer

blader/humanizer (MIT, SKILL.md declares v3.0.0) installs with npx skills add blader/humanizer --global; drop --global for the current project only, and it answers to /humanizer. It lists 25 numbered sentence patterns, and every one uses the same four slots: Watch for: (how to spot it) · Problem: (why it counts as a fault) · Before: · After:. The first two slots are the rule, the last two are the example. The rule names the thing; the example draws its border. Pattern 1, Not X but Y, ships this:

Before: It's not just about the beat riding under the vocals;
        it's part of the aggression and atmosphere.
After:  The heavy beat adds to the aggressive tone.

(Per that repo's main-branch SKILL.md, 2026-09.) What it kills is the unfalsifiable judgment "this reads like AI" — with four slots on the page, judgment drops to pattern matching. When not to install it: not as an always-on skill in a technical-docs repo, where the adverbs it strips are the precision you need (Skill 17 covered this).

Add one annotation line · stop-slop

boraoztunc/skills · stop-slop (393 lines) takes the other route: the pattern lists come first, and a standalone ## Examples block sits at the end with five pairs — each followed by a Changes: line, e.g. "Removed opener, binary contrast structure, and emphasis crutch."

That line is what makes an example transferable. Given before/after alone, the model may learn "short sentences are good." Given the Changes: line, it learns "what got cut was the throat-clearing opener and the binary contrast." It is also the line most people skip when they write their own examples. The move is to copy that three-line unit: Before / After / Changes. When not to install it: it competes with humanizer for the same trigger surface — run both and your voice changes every pass. Pick one.

The official criteria for the examples themselves

The "Use examples effectively" section of the official Prompting best practices gives three: relevant (mirror your actual use case) · diverse (cover edge cases and, in its own words, "vary enough that Claude doesn't pick up unintended patterns") · structured (wrap them in <example> tags so the model can tell examples from instructions). The recommended count on that page is 3–5 (per platform.claude.com, that page, 2026-09).

The counter-case: when one rule is strictly better

anthropics/skills · brand-guidelines is 73 lines with zero examples. Its constraints are #d97757, #141413, Poppins for headings, Lora for body text — a hex code needs no example, because it already is the acceptance criterion. If a constraint's value can be written down in one line, write the rule. Only what resists that gets an example. That's line one of the checklist in section 03.

// 03

Real usage and limits: how many, how to pick, where to put them

The claim: "how many is enough" has an answer you can count, and it isn't a total — it's 1–3 pairs per rule, with 3 as the hard ceiling.

How many: count the artifact

I counted all 27 second-level sections in blader/humanizer (per main-branch SKILL.md, 2026-09). Across its 25 sentence patterns: 14 carry one pair, 9 carry two, 2 carry three, plus 2 procedural sections (Voice / What to return) with none. Not one pattern exceeds three pairs. Read alongside the official "3–5 examples" guidance, the picture resolves: 3–5 is the total a model can hold for one judgment; per individual rule it lands at 1–3. Patterns that are hard to spot earn two or three; the obvious ones stop at one.

The author is actively subtracting. In blader/humanizer's README changelog, the v2.9.1 entry records removing "a repeated long example." More pairs is not better; the extra pair is just paying token rent.

How to pick: take them from rejected drafts, don't invent them

skill-creator writes this trap into its own body (per main-branch SKILL.md, 2026-09): "if the skill you and the user are codeveloping works only for those examples, it's useless." That is exactly the overfitting you get from polishing two or three examples in a loop — you and the model perfect those passages, and the skill dies on the fourth. The fix is sourcing: take them from drafts you actually sent back and actually revised, then run them past the three official criteria (relevant / diverse / structured).

Where to put them: examples are the most expensive thing in a SKILL.md

The official ceiling is 500 lines of SKILL.md body, and examples are the bulkiest, least compressible part of it. The remedy is progressive disclosure: move examples into sub-files and leave a router in SKILL.md. anthropics/skills · internal-comms is the extreme artifact of this: its SKILL.md is 32 lines, and the body is a routing table — by communication type, go read examples/3p-updates.md (46 lines) · examples/company-newsletter.md (65) · examples/faq-answers.md (29) · examples/general-comms.md (15). What it kills is re-explaining your status-report format every single week. How to use it: copy the whole thing into your skills directory and swap those four format files for yours. When not to install it: its whole gathering step assumes Slack / Drive / Calendar MCP access — without those, all you get is formatting.

Now the honest part. That directory is named examples/, but what it holds is not input/output pairs — it's a format spec per communication type. The ## Example Formats section inside company-newsletter.md literally reads "- Announcement 1 / - Announcement 2 / - Announcement 3". It gives you a skeleton, not sample prose. Why? Real internal company comms can't go into a public repository. That's a constraint, not laziness — and it's yours too: don't stuff client or internal drafts into a public repo as examples.

The overlooked inversion: examples aimed at the human

anthropics/skills · doc-coauthoring (375 lines) puts all its examples on the input side. Its Step 3, Curation, simply lists four sample replies: "Keep 1,4,7,9" · "Remove 3 (duplicates 1)" · "Remove 6 (audience already knows this)" · "Combine 11 and 12." The text says to request brief justifications in order to learn priorities for the next sections — it uses examples to train the human, so the human's feedback arrives in a form it can learn from. How to use it: any skill that needs repeated feedback from you deserves three sample replies. When not to install it: it's a full co-authoring workflow from a blank page; if you only want a paragraph polished, this is a sledgehammer.

// 04

Costs and alternatives: three bills, and the third has no fix

The claim: examples cost you overfitting, tokens, and assimilation. The docs give you a fix for the first two. There is none for the third — and it never raises an error.

Bill one: overfitting. Anthropic wrote the warning into skill-creator itself (quoted above). Fixes exist: keep examples diverse, and test the finished skill on a task it has never seen.

Bill two: tokens. Examples take up the most room in a SKILL.md, and they're usually what pushes you past 500 lines. The fix is the internal-comms 32-line routing table: examples go to sub-files, and only the relevant one gets read.

Bill three: assimilation — and this one has no fix. Examples become a ceiling. The model will not hand you a better sentence than your After, because "resembling that passage" is precisely what it optimizes. The pairs you chose reflect your standard six months ago, and six months later it is still delivering at that standard, quietly, with nothing failing. The only countermeasure is rotating your examples. blader/humanizer consolidating 35 patterns into 25, then deleting a long example, is that countermeasure in action — an example library expires like anything else, it just doesn't tell you when.

What to do instead of examples

  1. Write a rule — when the constraint's value fits in one line. The artifact is brand-guidelines: 73 lines, zero examples, nothing but hex codes and font names. That is the correct call.
  2. Write a template — the Template pattern in the official best-practices: give the output skeleton, not sample prose. The strict version reads ALWAYS use this exact template structure; the loose one offers a sensible default format, but use your best judgment. The ## Example Formats block in internal-comms is this pattern, not the examples one.
  3. Write a validator — the official feedback loop (run validator → fix → repeat). Anything a script can check should not be taught by example; examples earn their cost only where machines can't verify.

// WHAT TO COPY FIRST

Copy these three (specific files, not methodology): ① Structure — the "Examples pattern" section of the official best-practices: three pairs, Input/Output, one "follow this style" line to close. ② Unit — the four slots from blader/humanizer: Watch for / Problem / Before / After, at 1–3 pairs per rule. ③ Annotation — the Changes: line from boraoztunc/skills's stop-slop, naming what each pair actually removed.

How to lay out the directory: follow internal-comms — SKILL.md holds only the routing table, examples live in sub-files. Just don't copy its naming: calling a folder of format specs examples/ has misled plenty of readers.

Explicitly do NOT write examples when: the constraint is a hex code, a font name or a fixed command that fits in one line (brand-guidelines is right to ship zero) · all you have is two drafts by the same person on the same day (diversity fails, overfitting guaranteed) · the examples contain client or internal material and the repo is public (this is exactly why internal-comms ships no real prose).

Three questions before you ship: can a machine verify this constraint? Then write a script. Can its value be written down in one line? Then write a rule. Neither, but you can produce two comparable drafts? Then write an example — and add that Changes: line.

// GLOSSARY

few-shot / multishot prompting
Putting a handful of worked input/output pairs in the instructions so the model follows suit. The examples pattern freezes this into a SKILL.md. The official count is 3–5.
Examples pattern
A section under "Common patterns" in the official best-practices: when output quality depends on having seen a model answer, ship input/output pairs.
Template pattern
Its neighbour in the same chapter: ship the output skeleton (section names, placeholders) rather than sample prose. It constrains structure, not voice.
progressive disclosure
SKILL.md keeps only the router; detail lives in sub-files and is read on demand. The 32-line body of internal-comms is the extreme case.
overfitting
The skill works only on the handful of examples you polished it against, and dies on anything else. skill-creator writes this warning into its own body.

// FURTHER READING