| name | define-done |
| description | Use when a prompt should be compiled into a requirements / definition-of-done spec before anything is planned or executed: it decomposes the intent into grouped, itemized, logically ordered OUTCOMES that must hold at the end (what, never how), each optionally carrying an acceptance check, written as a durable dod.md artifact that planners, mappers, and checkers consume. Triggers: "define done for this", "what are the requirements", "spec this before solving", "decompose this into a definition of done".
|
| version | 0.1.0 |
| author | agent |
| license | MIT |
| platforms | ["linux","macos","windows"] |
| metadata | {"hermes":{"category":"autonomous-ai-agents","tags":["requirements","definition-of-done","intent","specification","world-state"],"related_skills":["task-decomposer","relentless-solve","method-explorer","next-best-questions"]}} |
Define Done — compile a prompt into a requirements spec
Overview
Given an intent, produce ${HERMES_HOME}/specs/<slug>/dod.md: the definition of done.
You are the SPECIFIER — you decide what must be true, never how to make it true.
Do not plan methods, do not execute anything, do not research beyond what the prompt and
provided evidence contain (unresolvable ambiguities go under OPEN:).
The world-state test (apply to every item)
Every requirement must be phrased as a condition that IS TRUE at the end, checkable
by observation — never an activity.
| FAILS the test (activity) | PASSES (world-state) |
|---|
| Run the migration | every row in users has non-null tenant_id |
| Write unit tests for the parser | the parser has a test suite that exercises each grammar rule and passes |
| Deploy the service | the service answers GET /health with 200 from the public URL |
| Fix the login bug | a user with valid credentials reaches the dashboard; the regression test for issue #N passes |
If an item starts with a verb aimed at a tool, rewrite it as the state the verb would
produce. Group items by logical stage of world-state; order groups with [after:] by
dependency (this must hold before that can hold), not by execution sequence.
STEP 1 — Write the artifact, exactly in this shape
# DoD: <slug> STATE: draft | agreed | satisfied
INTENT: <one sentence — the outcome that must hold; immutable, never edit it>
HARD (inviolable): <list>
SOFT (relaxable, ranked): 1) ... 2) ...
REQUIREMENTS (markers: ○ unmet · ✓ met (receipt) · ~ waived (receipted reason))
- R1 <group: outcome that must hold> [after: —]
- R1.1 <itemized requirement> check: cmd — <command that proves it> ○
- R1.2 <itemized requirement> check: judge — <observable criterion> ○
- R1.3 <itemized requirement> ○
- R2 <group> [after: R1]
OPEN: <ambiguities you could not resolve — one line each; empty is fine>
AMENDMENTS:
- Checks are optional per leaf:
check: cmd — <command> when a command can prove it;
check: judge — <criterion> when only an observable criterion exists; bare when
neither. Know the cost of bare: a bare or judged item may later be marked ✓ ONLY with
a receipt stating what was observed.
- Fresh specs start
STATE: draft with every leaf ○. A human (or the calling loop's
policy) moves draft → agreed; satisfied is set only when every non-waived leaf is
✓ with a receipt.
STEP 2 — Amending (never rewriting)
INTENT: is immutable. Requirements change ONLY by appending to AMENDMENTS: with a
one-line receipted reason, then applying the change in place:
AMENDMENTS:
- c2 R2.3 waived — source system has no audit table; requirement unsatisfiable as stated
- c2 R2.4 added — discovered consumers cache the old schema; invalidation must also hold
Waived leaves get marker ~ with the reason after it. Never delete a leaf; never edit
INTENT; never mark ✓ without a receipt.
What this skill is NOT
No methods, tasks, tools, or plans — that is the task-decomposer skill (whose plans
trace back here via per-task serves: [R-ids] when a driver passes the unmet ids in).
No execution — that is the method-explorer. No research loops — unresolved questions
go to OPEN: (downstream clarify rounds rank them). The value of this artifact is that
it stays stable while methods fail and change underneath it.
