Was ist enthalten

Eine SKILL.md (die Anleitung) + eine Startvorlage. Eine Vorschau:

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.
4. Apply the quality bar (input: five draft skills → output: kit that passes every gate)
   Run each skill against the same bar before the kit ships: no task starts without a written spec; no code is 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; and nothing merges without a human review against the spec. A kit that fails any gate goes back to the skill that failed.
5. Compose the delegation workflow (input: passing kit → output: delegate-to-merged sequence)
   Wire the skills into the order a real delegation runs: spec defines the contract, plan approval aligns on approach, execution proceeds checkpoint by checkpoint, test loop verifies, merge review decides. Define the handoffs: the spec's acceptance criteria become the test loop's pass conditions and the merge review's checklist; a failed test loop sends the run back to execution, never straight to merge; a spec contradiction stops the run and returns to the human. The kit is only done when a delegated task can travel this whole path without an undocumented shortcut.
6. Maintain the kit (input: run failures, near-misses, spec disputes → output: updated spine and skills)
   After every run, log what went wrong: specs the agent misread, plans that missed a constraint, checkpoints that were too coarse to roll back cleanly. Each failure becomes a spine rule or a skill step. Tighten the spec template for the failure modes that repeat — the kit improves by making the contract harder to misunderstand, not by making the agent "smarter."

Vorschau der Startvorlage

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

Das Skill-Paket selbst (SKILL.md + Vorlage) ist auf Englisch verfasst.

Das komplette Skill-Paket kaufen — $4.99 Pro — alle 511 Skills