author-skill

Grow the loop's OWN capabilities: turn a recurring manual pattern into a reusable skill — autonomously, no human review. (This is the AI-first counterpart to human "write-a-skill" tools that stop to interview you.)

This is the loop writing its own tools — the sharpest expression of the loop-tick Prime directive (the driver acts, it doesn't wait for capabilities to be handed to it). When a step recurs, the loop manufactures the skill and wires it in, so next time it's one call. That self-extension is what lets one loop scale into many.

When

Invoked by /self-evolve (or directly) once a step has recurred across several ticks and is stable enough to freeze. Never author for a one-off — that's premature abstraction.

Procedure (fully autonomous)

1. Name + triggers. Short kebab-case name; a one-line description ending with explicit "Use when …" triggers (that's how the runtime matches it). One skill = one capability.
2. Write SKILL.md in the project skills dir (.claude/skills/<name>/SKILL.md):
   • frontmatter: name + description (with triggers);
   • body: a numbered PROCEDURE of FROZEN, checkable steps (a different agent could follow it and not diverge) + a short RULES block. AI-first: the skill ACTS / asks-and-answers itself; never "ask the user" except at a real human gate. Reference the substrate/helper where relevant.
3. Validate. Frontmatter parses; every step is concrete and checkable (no hand-waving); no human-in-the-loop except real gates; it doesn't duplicate an existing skill (extend/compose instead). If a step isn't checkable, sharpen it.
4. Wire it into the flow. Reference the new skill from the relevant profile/tick step (or note it under state.config.skills) so the loop actually invokes it. A brand-new SKILL.md registers as an invocable /command on the next session; mid-session, invoke it by reading + following the file directly.
5. Journal the new capability (name + why) via the helper; self-evolve graduates notable ones to memory.

Worked example (what the trigger + process actually look like)

• Trigger. A /self-evolve pass notices the loop has hand-written the same recorder-tally one-liner for 3 ticks running — SSH the box, read trades_*_shadow.jsonl, count variant fires by netSh sign. Stable, repeated, not a one-off → freeze it.
• Author. Name recorder-shadow-tally; description: "Tally shadow-variant fires/net by netSh sign on the recorder. Use when a tick needs the current standing of a shadow variant." Body = the frozen procedure: the exact box id, file path, variant filter, and python aggregation, with the output shape it returns.
• Validate + wire. Frontmatter parses; steps are concrete; no existing skill already does this. Reference it from the experiment profile's OBSERVE step (or state.config.skills).
• Journal + use. Record the new capability. Next tick, the hand-rolled heredoc becomes one call: /recorder-shadow-tally contra. A later /self-evolve GCs it if it stops being used.

Rules

• Author from a PROVEN recurring need, not speculation. Frozen, checkable, AI-first instructions matching the existing skills' shape. Don't duplicate — compose. No human review path.