Skills That Build Skills

Why durable skills carry their own templates

The Design Choice

A reusable skill has two parts — and where you put the reference decides if it survives

In amplifier-bundle-skills, a "scaffold a service" skill needs the steps to follow and a working reference to copy from. Whether that reference lives inside the skill or points outward is the whole game.

First, the evidence that these reusable skills are real.

Part one: the steps to follow
Part two: a working reference to copy from
The choice: embed it, or point at it

The Evidence

One commit shipped 10 production pattern-library skills

Commit bfe4044 (Brian Krabach, 2026-04-14) added the 10 *-patterns skills in 2,292 insertions — its body: "36 reusable patterns extracted from production Python CLI tools, web services, and React frontends."

Reusable scaffolding skills are real. So how do you keep them from rotting?

10

pattern-library skills, one commit

2,292

insertions across 11 files

36

reusable patterns (per commit body)

The Tempting Shortcut

Write the steps, point at a live reference service — and watch it go dead

The obvious way to make a "scaffold a new service" skill is to write down the steps and point at a working reference service in the workspace. But that pointer breaks the moment the workspace churns, and the know-how goes with it.

The durable design in this repo does the opposite.

The Antidote

Every pattern skill carries its own Template / Starter Code — 10 of 10

Instead of pointing outward, each pattern skill embeds a ## Template / Starter Code section with full working code inline. In http-service-patterns that block is a complete FastAPI app.py starter — right inside SKILL.md.

And that inline code isn't just a static copy.

10/10

pattern skills with an inline Template / Starter Code section

49

numbered Key Design Decisions carried in-file across the 10 skills

Self-Contained Scaffold

The embedded templates use placeholder tokens, filled in place

self-managing-tool-patterns ships _SYSTEMD_UNIT_TEMPLATE and _LAUNCHD_PLIST_TEMPLATE with {exec_start} and {safe_path} tokens, filled via .format(...). The template lives in the skill — nothing points outward at a repo that can churn.

Doing this reliably is itself a repeatable process.

# self-managing-tool-patterns/SKILL.md
_SYSTEMD_UNIT_TEMPLATE = """
ExecStart={exec_start}
Environment=PATH={safe_path}
"""

_SYSTEMD_UNIT_TEMPLATE.format(
    exec_start=exec_start,
    safe_path=safe_path,
)

Meet the Meta-Skill

skillify captures the whole process as a repeatable 6-step skill

Added in commit 2bdec3b (Brian Krabach, 2026-04-07), skillify is a 253-line SKILL.md whose entire job is to turn a session into a reusable skill — a fixed 6-step process, enforced by a test that asserts exactly six headings in order.

Then it does something recursive.

Consult Skills-Assist
Analyze the Session
Interview the User
Write the SKILL.md
Test the Skill
Review and Save

The Recursion

skillify eats its own dog food

The skill that builds skills applies the very pattern it teaches: it embeds its OWN SKILL.md template with 17 {{placeholder}} tokens inline. test_skill_content.py asserts the exact 6 steps in order — and that the template stays present.

Self-contained templates, applied to skill-building itself.

17

{{placeholder}} tokens in skillify's own embedded template

253

lines in skillify SKILL.md

6

steps a test asserts stay in order

The Pattern Generalizes

"Carry your own template, don't point outward" is now a captured, repeatable process

personafy (#25, Brian Krabach, 2026-06-08) is a second meta-skill: it drafts each new skill "to the family template" and reproduces the shared template and metadata shape. The move from fragile pointers to self-contained templates isn't a one-off — it's reproducible.

Pointers rot; carry your own template — and capture the act of doing it.

Sources

Research Methodology

Data as of: 2026-06-19 (latest commit at checkout)

Feature status: Merged and shipped in the curated collection

Repository: ramparte/amplifier-bundle-skills (origin); microsoft/amplifier-bundle-skills (upstream); checked out at ~/dev/ANext/_work-amplifier-bundle-skills

Commands run:

wc -l skills/skillify/SKILL.md → 253 lines
git show 2bdec3b --format='%an | %ai' -s → skillify, Brian Krabach 2026-04-07
git show --stat bfe4044 | head -80 → 10 pattern skills, 2,292 insertions, "36 reusable patterns"
grep -rl '## Template / Starter Code' skills/*/SKILL.md | wc -l → 10
grep -o '{{[^}]*}}' skills/skillify/SKILL.md | wc -l → 17
sed -n '143,190p' skills/self-managing-tool-patterns/SKILL.md → _SYSTEMD_UNIT_TEMPLATE with {exec_start}/{safe_path}
grep -rhcE '^### [0-9]' skills/*-patterns/SKILL.md → 49 Key Design Decisions
git show 1a7b9d0 --format='%an | %ai' -s → personafy (#25), Brian Krabach 2026-06-08
ls -d skills/*/ | wc -l → 27 skill directories

Gaps: The "36 patterns" figure comes from commit bfe4044's message body, not an independent heading count; an independent count of numbered design-decision sections gives 49 (reported separately, not reconciled). No literal "reference-count broke" figure exists in the repo; pointer-rot is the story's framing, not a repo fact.

Primary contributor: Brian Krabach (40 commits under brkrabac@microsoft.com; author of skillify, the pattern library, and personafy)