The Skill Grows Up

A Markdown file that runs itself

The Wall

A skill was just a Markdown file—until it needed to be more.

Amplifier skills packaged expertise as one portable SKILL.md, injected into context on demand. But the decision guide skills-vs-agents.md documented the cliff: the moment a task needed isolated context, its own model, scoped tools, or an enforced guardrail, you had to "graduate to an agent" and author a full bundle.

Now that graduation is gone—and it's already shipped.

Shipped, Not Proposed

This isn't a proposal: it shipped as v1.1.0 and it's tested.

The tool-skills module that implements the enhanced format is about 2,361 lines of Python across 6 files—and it's covered by a real test suite.

So what wall did all that code actually knock down?

1.1.0

Shipped & tagged version (v1.1.0)

2,361

Lines of Python across 6 files

243

Test functions across 23 test files

The Cliff, Named

The decision guide spelled out exactly when you had to abandon the skill.

Amplifier's own skills-vs-agents.md guide named the four triggers that forced you off a portable Markdown file and into a full bundle.

The enhanced frontmatter answers each one—starting with isolation.

Isolated context — the task needed its own separate session
Non-default model — the task needed a different model than the parent
Tool restriction — the task needed a scoped-down toolset
An enforced guardrail — the task needed a lifecycle hook

How #1 — Isolation

`context: fork` runs a skill as an isolated subagent—no agent authored.

A forked skill spawns via session.spawn as its own subagent. fork is the only valid context value—any other is rejected with a warning. And forks can't nest: a forked skill invoking another fork is blocked to prevent infinite recursion.

Isolation solved. Next: which model does that fork run on?

# code-review/SKILL.md
context: fork
disable-model-invocation: true
user-invocable: true
model_role: critique

# _execute_fork() ->
# spawn_fn(agent_name='self', ...)
# fork-from-fork: blocked

How #2 — Routing

A 5-level precedence chain picks the skill's model, right in the frontmatter.

model_resolver.py walks an explicit order and resolve_skill_model() reports which level won—so model routing lives in the SKILL.md, not in a separate agent definition.

Isolation and routing, done. The last trigger was a guardrail.

provider_preferences ▲
model_role
model (hint)
agent (archetype)
inherit (nothing set)

How #3 — Lifecycle

Auto-load skills that declare hooks wire straight into the session lifecycle.

When a skill sets auto_load and declares hooks, it emits skill:loaded at mount and skill:unloaded on cleanup—an enforced guardrail from a Markdown file, no bundle required.

Three triggers answered. But did we just trade portability for power?

Mount — auto_load + hooks emits skill:loaded (auto_loaded=true)
Cleanup — each loaded skill emits skill:unloaded
Sandboxed shell — preprocessing strips env to a safe allowlist, caps output at 1 MB

The Pivot

You gain agent-like power and keep one portable file—not a fork in the road.

Because every new field is additive to the open Agent Skills spec, the same file still runs across four harnesses. Including Amplifier extensions in a Claude Code skill causes no errors—those fields simply have no effect.

Which means the "graduate to an agent" cliff is gone entirely.

4

Harnesses in the compatibility matrix

Amplifier

Copilot · Claude Code · Codex

The Payoff

The graduation is gone: a static Markdown file is now a lightweight runtime.

27 curated skills ship in the directory. Power skills—code-review, mass-change, session-debug—and the expert skills-assist use context: fork, running isolated, routed, and recursion-guarded from one SKILL.md that still travels everywhere.

No agent required.

27

Curated skills in the directory

4

Forked power / expert skills (code-review, mass-change, session-debug, skills-assist)

Sources

Research Methodology

Feature status: Shipped & tested · v1.1.0

Repository: amplifier-bundle-skills (origin → ramparte/amplifier-bundle-skills; upstream → microsoft/amplifier-bundle-skills). All facts grounded in this checkout.

Primary contributor: Brian Krabach (45 of 52 commits via git shortlog -sne --all).

Commands run:

wc -l modules/tool-skills/amplifier_module_tool_skills/*.py — 2,361 lines across 6 files
cat model_resolver.py — 5-level precedence chain
grep -rh 'def test_' modules/tool-skills/tests/ | wc -l — 243 test functions across 23 files
uv run pytest ... — 57 passing in a minimal env (model_resolver 10/10, auto_load 14/14, preprocessing 22/22, discovery 11/11); enhanced_discovery 27/28
ls -d skills/*/ | wc -l — 27 skill directories
sed -n '846,966p' __init__.py & git show 408131a -s — fork via session.spawn; recursion guard
grep -niE 'claude code|copilot|codex' compatibility-matrix.md — 4-harness matrix
git tag ; git log --oneline | grep 1.1.0 — v1.1.0

Gaps: The full 243-test suite was not run to completion; 2 fork/model-role tests could not run because the optional amplifier_foundation routing-matrix provider is not installed here (an environment gap, not a code defect). Additive frontmatter fields count as 9–11 depending on grouping; the enhanced dataclass groups 9.