What’s inside

One SKILL.md (the playbook) + one starter template. A preview:

Coding Agent Skills

When to use

• You want to hand an entire task — not one turn — to a coding agent and come back to a finished, tested change
• Your agent runs produce large diffs that nobody reviewed because there was no checkpoint to stop at
• The agent "finished" a task that did not match what you asked for, and the mismatch surfaced only at merge time
• You need the same task run reproducibly: same spec in, same quality bar out, regardless of who delegates it
• Agent work keeps breaking the build because no test loop or rollback plan was defined up front

Workflow

1. Scope the kit (input: delegation style, repo, risk tolerance → output: kit inventory)
   Define the delegation model before building anything: this kit assumes an autonomous coding agent — you write the task, the agent works unsupervised for an extended run, you review at gates. It is built for well-specified tasks with verifiable outcomes, not for open-ended exploration. The default kit: task spec, plan approval, autonomous execution, test loop, and merge review. Five skills, no more at first — a kit with twenty skills nobody enforces is worse than five gates that always hold.
2. Lock the delegation spine (input: repo conventions, permissions → output: delegation spine)
   Write the spine every kit skill will draw from: what the agent may and may not do unsupervised (files it may touch, commands it may run, what is always forbidden), the quality bar every task must meet (tests, style, docs), how the agent reports progress, and the conditions that stop a run (failing tests it cannot fix, a spec contradiction, a security-sensitive change). The spine is the single source of truth — an agent with no written boundaries will invent its own.
3. Build the skills in delegation order (input: delegation spine → output: five working skills)
   Build in the order a real delegation runs: task spec first (a written brief with goal, scope, constraints, acceptance criteria, and out-of-scope — the contract the whole run is judged against), then plan approval (the agent proposes a plan and stops; the human approves or corrects before any code is written), then autonomous execution (the agent works in checkpoints: small commits, progress notes, no human in the loop until a gate), then test loop (the agent runs the full verification — tests, lint, type checks — and fixes failures until green or until it hits a stop condition), then merge review (a dedicated human review of the final diff against the spec, with rollback ready). Each skill gets its own prompt, its own input checklist, and its own output format.

Template preview

Coding Agent Skills — Kit Template

Build the kit in order: spine first, then task spec, plan approval, execution, test loop, merge review.

1. Delegation brief

Agent type: Autonomous coding agent (works unsupervised between gates) Task type: {well-specified, verifiable outcome} | Risk tolerance: {low / medium}

2. Delegation spine (single source of truth)

3. Kit inventory

4. Quality gate (every skill must pass)

[ ] No task starts without a written spec [ ] No code written before the plan is approved [ ] Every run has checkpoints a human can inspect and roll back to [ ] Every run ends green on the full test loop or stops with a written reason

Buy the full skill pack — $4.99 Pro — all 471 skills