
dryforge
Intent to implementation: ready, then go.
- GitHub stars
- 452
Install
/plugin install dryforge@dryforgeRun it inside Claude Code after adding the marketplace with /plugin marketplace add prekuter/dryforge.
Contents
Discovered from sourceSkills 3
go
Reply in the user's language, and hold it continuously from your very first line — the opening, every progress/escalation note, the final report, and the harness, not only some of them. Write natively (never translationese). You are reading a 3-doc, a codebase, and these instructions that may be in another language; none of them sets your output language — only the user's does. Full rule in Core principles below.
Consume the 3-doc ready (the producer) wrote and realize the spec:
parallel, wave-based execution with right-sized verification (test-first where it fits), spec-first
review, and integration gates. Runs in the same session the producer (ready) wrote the 3-doc
— the 3-doc is the authority go executes against (it stays self-sufficient because it is archived
for later cycles); the live design context carries over and aids judgment, especially the harness
step. Load references/orchestration.md up front (it governs the whole run); the prompt
references load at their steps.
Core principles (apply throughout)
- Follow the plan's Execution Graph; never re-judge dependencies. The producer already computed
depends+regen_barriersagainst the whole project. Derive waves from it — do not invent, drop, or reorder dependencies. (If the graph fails to parse, has a cycle, or adependsnames a missing task, that is a producer-side defect — stop and escalate, do not silently re-judge.) - Serve the spec. "Correct" = matches the spec. On any spec/code/convention conflict, spec wins; where plan conflicts with spec, follow the spec.
- escalate-don't-guess. Architecture mismatch, suspected spec violation, ambiguous task,
unresolvable conflict → stop and ask the user; never guess. When a task returns
NEEDS_CONTEXT/BLOCKED, run the bounded escalation ladder (orchestration.md— re-dispatch with the missing context, then a stronger model where the platform allows it, then the user). Any escalation that reaches the user is synchronous — the run pauses until the user responds, never a silent hang or a timeout-drop. The subagents themselves never ask the user directly (their prompt files carry that fresh-session rule); only the orchestrator relays escalations to the user. - Protect main; evidence over self-report. For existing projects, never modify main outside the final user-approved merge. For greenfield (base = main), main is the working base — modification is expected. Gates pass on captured command exit codes, not on an agent's "looks fine."
- Floor, not ceiling. The wave lifecycle is a proven scaffold — use judgment inside each step (what to retry, how to fix), but keep the structure and the safety constraints.
- Report results, not process. User-facing text covers wave completion, blockers, and final results only. Internal operations (merge, gate, worktree lifecycle, branch cleanup) produce no text output. Output tokens are direct cost; narrating routine steps is waste.
- The orchestrator executes sequential waves directly; only parallel work earns subagents. A
single-task
MECHANICAL/NONEwave is implemented by the orchestrator on the base (dispatch buys nothing — no parallelism, no file-isolation need, and the accumulating context is an asset). Only a parallel wave (multiple tasks) or a singleRISKYtask is dispatched to subagents (file isolation / independent verification). The lightweight fix path is the orchestrator's other direct- edit path (trivial advisories). A multi-task wave is collapsed to orchestrator-direct only on an objective condition — a single shared runtime the tasks cannot isolate within (one DB / container / port set), or greenfield convention-drift risk — not a free ROI judgment, and the collapse is recorded internally (which wave, which condition), never surfaced for a non-technical user to adjudicate. Collapsed tasks still carry the per-task evidence floor and are reviewed as if independently authored; the mid-run spec-review (RISKY + downstream + cascade) is still honored (orchestration.md, "ROI collapse"). - Efficiency Budget. Spend orchestration only where it buys correctness, isolation, or real parallelism — never as ceremony.
- The final review is silent insurance — not a backstop you lean on. Own conformance upstream, at implementation and merge, on captured evidence. Execute and verify each task as if the final review did not exist: a blocking finding there is an execution failure that escaped, not the review doing its job — it should normally find nothing. Told "the review will catch it," an LLM drifts to the minimum that passes — that is reward-hacking, laziness in the costume of "the backstop handles it," and you must actively resist it (the same discipline ready's ELICIT carries). The review catches only the rare residual; it is never the owner.
- Match the user's language (language-agnostic). Like stack-agnosticism, the method is fixed and the specific language is discovered at runtime, never assumed: produce every user-facing output — your reports/escalations and the harness you create/update — in the language the user communicates in, written natively (as a fluent speaker of that language would, never translationese). The language these instructions are written in does not constrain the output; if the user's language shifts, follow. Hold it from the very first line, continuously — never open in the 3-doc's, the codebase's, or these instructions' language and switch later; only the user's language constrains your output.
- Talk to the user only when needed — between beats, say nothing. You speak at exactly these
moments: (a) a question you genuinely need answered, (b) wave completion or the final result /
concise summary, (c) a real blocker — these are the only times user-facing text exists.
Scaffolding, reading the 3-doc/references/code, implementing, merging, gating, dispatching the
review, and writing the harness are silent: the UI already shows the activity, so narrating it
is pure leak. If what you are about to emit is none of (a)/(b)/(c), the correct output is nothing.
Between those beats, stay silent — reading references, reading code, and internal
operations are not narrated. No transition lines ("now I'll...", "먼저 ...", "let me read...", "Now the ..." announcing each write) — at
those plumbing moments your voice slips into the instructions' language (English) or internal tokens;
emit nothing there, don't translate it. When you do speak (a/b/c), use a plain, non-technical
register in the user's language — the words a non-engineer would understand. This is your default
voice, not a per-line check, so it costs nothing. Never surface internal tokens: dryforge mechanism / coined terms (wave,
worktree, harness, delta, 3-doc, gate, seam, ROI collapse, spec-review, grounding, lens,
invariant), task / step / risk labels (
T1,Wave 2, RISKY / MECHANICAL / NONE), or project-internal jargon a non-engineer wouldn't recognize (library/tool names, config flags, test-framework internals). Don't soften internal logic into user-ish words — just omit it. E.g. "Starting a git repo here." — not "Since go will later need git for worktrees, I'll initialize one." This is "Report results, not process" applied to narration.
Input & preconditions
- Invocation: the user invokes the
goskill. Load the 3-doc (handoff → spec → plan) from the project's.dryforge/(project-root-relative). If absent, ask for the path. - git required — worktree isolation depends on it. If not a repo, offer
git initand make an initial commit (an empty repo has no HEAD, so no worktree/branch can be created). If git is not installed, stop and say so. - Base determination. Identify the project's main branch (docs / remote default / ask — do not
guess). Verify
mainhas no unpushed commits (when it tracks a remote — a purely local repo has nothing unpushed) and the working tree has no modified/staged tracked files; if either fails, stop and report. Then classify:- Greenfield (main has no application code — only an init commit,
.gitignore, or producer-generated.dryforge/): base = main. No feature branch — there is no production code to protect. - Existing project (main has meaningful committed code): base = feature branch created
from main (
git checkout -b dryforge/<feature>). Protects main from incomplete work. .dryforge/as untracked files is the expected handoff state from the producer — do not treat it as a dirty tree. Anything else untracked or modified is foreign work → stop and report.- You own the
.dryforge/git mechanics. On the base, add.dryforge/to.gitignoreand commit. For existing projects this stays on the feature branch (never on main); for greenfield it is on main (acceptable — main has no meaningful history to protect). If a prior run left.dryforge/tracked, rungit rm -r --cached .dryforge/first.
- Greenfield (main has no application code — only an init commit,
- Verify commands — the project's build/test/lint commands are typically declared in the handoff (hard gates section) or discovered during scaffold from the project's build scripts. Identify them before the first wave; they are used in every integration gate and the completion gate.
- Read handoff first (it governs: document roles, hard gates, execution shape), then spec and
plan. First-cycle precondition (check now, not at the end): if this is a first cycle (no
.dryforge/status.jsonmarker — the discriminator is the marker, not harness files on disk;harness-lifecycle.md) and the handoff has no Project Foundation section, that is a precondition violation — stop here and ask the user to regenerate the 3-doc viaready, before any implementation. Do not discover this at step 9 after a wasted run (harness-lifecycle.md). If the handoff has a Project Foundation section (first cycle —references/foundation-format.md), read it as non-executable project context: it informs implementation judgment (design the task to fit the project's wider domain/decisions) and is a source for the harness at the end — it is not an implementation target. Build the spec's task, using the Foundation as context. Parse the plan's Execution Graph perreferences/graph-contract.md— the consumer-side schema (what the YAML fields mean and the rules go must hold when reading them). It mirrors the producer's authoring schema; if the plan's graph contradicts it, that is a producer-side defect → stop and escalate.
Graph validation (before any irreversible worktree creation)
Validate the plan's Execution Graph before creating the base — it is cheap and safe
to fail (no git state mutated yet), so catch a malformed graph before any worktree exists to unwind.
Parse the YAML, then confirm the graph is acyclic, that every depends / after id names a
real task (no dangling reference), and that the plan body and the graph agree on the task id set
(no graph task missing from the plan body, none in the body absent from the graph). graph-contract.md
is the authoritative rule set for these checks. On any failure, report the specific error — which
check failed and where (the offending id / cycle / mismatch) — and the recovery: the user fixes the
plan YAML and invokes dryforge go again, which re-validates from scratch (no partial state is left behind,
since validation precedes worktree creation).
Flow
Parse the graph → topological sort into waves (batches of ≤8 concurrent). Set up the base
(per Base determination): for existing projects create the feature branch, for greenfield stay on
main. On the base, set up .dryforge/ (gitignore + commit — the 3-doc is already in place from the
producer; same working tree, nothing to copy). The orchestrator reads
.dryforge/ here — task subagents do not; they receive spec slices inline (orchestration.md).
A task whose declared work targets are state/external only (no file diff) is handled on the base
sequentially, never dispatched into a parallel worktree — the file-diff merge-gate cannot verify
it and worktree isolation buys it nothing (orchestration.md, Wave scheduling). Then, per wave:
Scaffold (inline, before dispatch). Project initialization — manifests, dependencies, directory layout, build config, server/client entry points, shared types — is the orchestrator's job, not a task. On the base, perform scaffold inline: read the spec's tech decisions and set up the project so implementers start in a working skeleton. Scaffold is not in the Execution Graph. Batch file writes — scaffold typically creates many independent files; write 4–5 per tool-call turn instead of one at a time. Each extra turn adds thinking overhead and an API round-trip. Exception: if scaffold requires investigation or trial-and-error to get right (e.g. container orchestration, CI pipeline configuration, or 30+ files across 3+ workspaces), dispatch it as an implementer before the first wave.
Review policy (natural language, orchestrator judgment).
Default: a single final review after all waves merge — one subagent checks the full diff for
spec conformance + code quality (reviewer-prompt.md), plus the harness (content + format) when it
was created/updated this cycle (step 9). This replaces per-task spec-review and per-wave code-review
for most graphs. Mid-run review is added only when the orchestrator judges
that a RISKY task with downstream dependents could cascade a deviation — then that task gets a
spec-review before merge. The judgment comes from the Execution Graph: risk + depends.
Lightweight fix path: after the final review, the orchestrator MUST triage each advisory finding:
trivial (1–2 files, non-behavioral, e.g. a missing step attribute, a test warning, a one-line
comment) → edit directly on the base, commit, re-run the completion gate. Substantive (structural,
multi-file, behavioral) → fix-dispatch subagent. The default is lightweight — only escalate to
fix-dispatch when the change warrants independent review. Do not skip advisories as "accepted"
when a lightweight fix would take seconds.
Sequential wave (single task — the common case). Execution mode is set by the task's risk
(full rules in references/orchestration.md):
- Pick the mode by
risk.MECHANICAL/NONE(file-diff task) → orchestrator-direct. The orchestrator reads the task's behavioral contract + spec slice itself and implements directly on the base — no dispatch, no worktree, no prompt authoring. The same captured-evidence floor that binds a dispatched implementer binds you here (implementer-prompt.md): right-sized but real verification (command + captured exit code; real testable behavior left untested = not done, never a "right-size" excuse). Commit on the base. You own conformance on this path — the final review is insurance, not your check. If the task proves ambiguous, behavioral, multi-file, or riskier than declared, treat it as a runtime risk upgrade (graph-contract.md) and strengthen verification.- Omitted
risk(producer did not judge) → unclassified, notMECHANICAL. Do not default it to the direct path: judge at read time and bias toward dispatch / stronger verification the moment any behavioral surface appears (orchestration.md,graph-contract.md— degrade-don't-corrupt). RISKY(file-diff task) → one subagent in a worktree (implementer-prompt.md), then merge-gate into the base — independent verification, so the final review is not the only check on risky work.- No-file-diff task (any risk) → base-pinned subagent, verified by commit message + captured external evidence.
- Collect or record — for a subagent, keep its structured summary; for orchestrator-direct work, record files changed, commands run, and concerns in the same shape.
- Spec review (conditional,
spec-review-prompt.md, before merge) — only when the review policy calls for it (RISKY task with downstream dependents): review the task branch's diff before the merge-gate, so a deviation never lands on the base. - Land + verify — confirm the commit on the base (
git log, diff touches declared targets; no-file-diff: commit message + captured external evidence). RISKY worktree: merge-gate into the base. Then run regen barriers and deferred wiring if applicable, committed on the base. No integration gate — the self-checks on the cumulative base are sufficient for a single-task wave. → next wave.
Parallel wave (multiple tasks — worktree isolation required):
- Worktree pool (first parallel wave only) — if the graph has multiple parallel waves,
pre-create
max(wave sizes)worktrees once under.dryforge/worktrees/; recycle between waves instead of remove+recreate (seeorchestration.md). For a single parallel wave, create on demand. - Create task worktrees — serially (avoid
.git/config.lockcontention), under.dryforge/worktrees/<task-id>(inside the gitignored.dryforge/, so they never sprawl into the project tree or get tracked), each branched off the base (or reset a pooled worktree to the current base tip). If the project has an installable dependency tree, install or share it (sharing guidance inorchestration.md). - Dispatch implementers — one subagent per task, in parallel, ≤8 at a time
(
implementer-prompt.md): right-sized verification, shared-write constraints, pinned worktree path. Dispatch every implementer and reviewer as a general-purpose subagent (full read/edit/run tools — never a plan-only or search-only agent type: an implementer must edit and run, a reviewer must read and cross-check). - Collect — each returns a structured summary.
- Spec review (conditional, before merge) — only when the review policy calls for it.
- Merge serially into the base. Merge-gate per task (objective, not existence-only): the task
branch is strictly ahead of the base (
git rev-list base..tasknon-empty) AND its diff is non-empty and touches declared targets — checked with three-dot diff (git diff base...task). The merge commit message must satisfy the project's commit-msg hooks. Then run regen barriers, then deferred wiring (check-before-append, idempotent; conflicts → escalate) and commit wiring on the base. - Integration gate — run the project's verify commands on the merged result after wiring is committed; green = exit 0, output captured. This catches cross-task interactions that no single implementer could see. Failure → analyze → fix-dispatch or escalate.
- Clean up or recycle task worktrees. If a later parallel wave exists, recycle pooled
worktrees (
git checkout <base-tip> && git reset --hard) instead of removing. If no later parallel wave needs them, defer cleanup to after the completion gate — batch-remove all worktrees at once. Only remove after asserting each task's commit is an ancestor of the base (git merge-base --is-ancestor); if not, do not remove — escalate. Prefer safegit worktree remove(no--force). Remove dependency-share symlinks first (slash-less<dir>pattern). Delete merged task branches (git branch -d). A failed task's worktree and branch are preserved for diagnosis. After the final batch-remove, also delete the now-empty.dryforge/worktrees/directory and any task temp dirs —.dryforge/should hold only the active 3-doc,NNN/archives,status.json, andbackup/(no litter). → next wave.
After all waves:
-
Completion gate — the full verify set on the base. SHA reuse rule: if the last parallel wave's integration gate passed, ran the full verify set (not the affected-only subset), AND the base tip SHA has not changed since that gate (no lightweight fix, no wiring, no regen committed after it), the completion gate is satisfied by the prior gate's captured result — do not re-run. If any commit landed after the last gate, or that gate was affected-only, re-run the full verify set.
-
Harness create / update (
references/harness-lifecycle.md+references/harness-format.md, force-load). After the completion gate, before the final review: re-read the 3-doc (mandatory — the session is now code-biased), then act on the local marker.dryforge/status.json:- First cycle (marker absent): create the whole harness — CLAUDE.md / AGENTS.md +
docs/+ module AGENTS.md — from the handoff's Project Foundation + spec + code. The Foundation is a first-cycle invariant (readyalways writes it); if a first-cycle handoff has no Foundation section, do not guess one from spec + code — stop and ask the user to regenerate the 3-doc viaready(harness-lifecycle.md, fail-fast precondition). Back up + critically rework any existing CLAUDE.md / AGENTS.md with user approval. - Delta (marker present): update only the changed-scope
docs/(read all current docs first; escalate an in-scope conflict; new module → new AGENTS.md + navigation-tree update). Seeharness-lifecycle.mdfor the marker rule and the clobber safety guard. Write every file silently — do not announce each file or section as you go ("Now the docs...", "이제 모듈 노트를...", "Now the module roadmap note inX"); the UI already shows each write. This multi-file writing sequence is the last place narration leaks — emit nothing between writes.
- First cycle (marker absent): create the whole harness — CLAUDE.md / AGENTS.md +
-
Final review — one subagent checks the full diff on the base for spec conformance + code quality, and the harness (when created/updated this cycle) against
references/harness-review.md(reviewer-prompt.md, four lenses). Clear = zero blocking findings, recorded. -
Fix if needed — lightweight fix path for trivial advisories (MUST triage); fix-dispatch substantive findings. Fixes may touch code or harness. Re-run per
harness-lifecycle.md: code changed → re-run completion gate; harness changed → re-run harness review; both → both. A finding about a doc/code mismatch outside this cycle's change scope is not fixed here — record it indocs/tracking/findings.mdand defer (scope-limited delta). -
User gate. Present for approval. First cycle: present the code result and the harness as a reconciliation against the decisions the user took part in — "the [X] we agreed is recorded in the harness as [this]" — not a raw document dump. Later cycle: include a harness-change summary in the result report.
-
Archive (move) + mark. On approval, move the active 3-doc into
.dryforge/NNN/— copy.dryforge/{handoff,spec,plan}.mdinto the new highest+1 dir, then delete them from the.dryforge/root (archiving is a move, not a copy — leave no stale active 3-doc at root). Write.dryforge/status.json({ "initialized": true }) if absent — the local marker that makes the next cycle a delta.
Advancing waves. Sequential waves advance immediately after commit verification — no gate to
wait for. For parallel waves, the next wave's provisioning SHOULD overlap the current wave's
integration gate (orchestration.md, Advancing waves), but dispatch waits for a green gate.
Fall back to fully serial advance if uncertain.
Mechanics, subagent dispatch constraints, status protocol, context budget, and failure handling live in
references/orchestration.md.
Completion gate (avoid self-judgment A=A)
Done only when ALL hold — on evidence, not assertion:
- every wave merged; every spec requirement traced to a merged task; zero open
BLOCKED/ needs-fix. "Zero open BLOCKED" is not "counted as done" — each BLOCKED task must have completed escalation to the user (the user has been told and has resolved its disposition) with its worktree preserved for diagnosis; a BLOCKED task may never be silently tallied into "done". - every
DONE_WITH_CONCERNSconcern resolved (fix-dispatched) or explicitly accepted and recorded (at code-review or by the user) — a flagged concern is never silently carried into "done". - a final full check — all of the project's verify commands (whatever the stack actually has
— e.g. typecheck / lint / test / build, or fewer; including any genuinely expensive end-only step
deferred from the per-wave gate) on the integrated base exit 0, with the commands and
exit codes captured and shown (not "looks green"). Why re-run everything when each wave already
passed: a per-wave gate proves each wave green in isolation, but the integrated result can break
on cross-wave interactions that no single wave's gate could see — so the completion gate re-runs
the full verify set against the whole base as the final, all-together check. Running the
full verify set every wave is the safe baseline; narrowing to an affected-only subset is an
optional efficiency lever for intermediate (per-wave) gates only — never for the completion
gate. Affected-only is permitted when the project's test runner supports change-based filtering
(e.g. the test runner's change-based filter —
--changed,--since,--lf, or equivalent). When using affected-only, record what was skipped so the completion gate's full run covers it. The completion gate always runs the full verify set — it is the cross-wave safety net. - runtime smoke — in addition to the verify commands above (which prove the code compiles and tests pass): when the spec declares a running server or service, start it, send one health-check or minimal request, confirm a 2xx response, then stop. A green build proves the code compiles; a runtime smoke proves it boots and responds. Skip only when the project has no runnable server component.
- An unevaluable check is a fail, not a pass. A verify or smoke command counts as green only when its assertion itself evaluated and reported success — exit 0 from the assertion, or the expected output actually observed. If the assertion could not run (the command errored before asserting, the server never came up, the matched output was empty, the response couldn't be parsed), that is a failure — diagnose it, fix the check (or the code), and re-run until the assertion genuinely passes. Never infer a pass from side-effects ("the server logged the request", "a file appeared", "no error printed") when the declared assertion did not itself succeed; a check you can't evaluate is not evidence. (This is A=A self-judgment applied to the gate's own evidence — see header.)
- no residual escalation outstanding — every task that returned
NEEDS_CONTEXT/BLOCKEDwas resolved through the bounded escalation ladder, and any escalation that reached the user was synchronous (the orchestrator pauses the run and waits for the user's response — never a silent hang or a timeout-drop). Subagents themselves never ask the user directly (the prompt files carry that fresh-session rule); only the orchestrator relays escalations to the user.
Finish
After the harness step, final review, user approval, and 3-doc archiving (steps 9–13 above):
- Greenfield (base = main) → work is already on main. Notify the user that the project is complete on main. No merge needed.
- Existing project (base = feature branch) → ask the user how to integrate:
- Merge to main → fetch and confirm main has not moved (if it has, re-integrate / escalate);
merge the feature branch with
--no-fffrom a checkout on the main branch. On conflict, abort and escalate. After confirming the merge, clean up branches. - Open a PR / push → push the feature branch; leave integration to the project's review flow.
- Hand off only → keep the feature branch intact. Never integrate on your own.
- Merge to main → fetch and confirm main has not moved (if it has, re-integrate / escalate);
merge the feature branch with
migration
Reply in the user's language, and hold it continuously from your very first line — the opening, every grounding/progress note, the questions, and the harness, not only some of them. Write natively (never translationese). You are reading a codebase (and these instructions) that may be in another language; neither sets your output language — only the user's does. Full rule in Core principles below.
Convert an existing project into the dryforge project harness — the durable documentation layer
that every later agent (dryforge or not) works inside. migration reads the codebase, elicits the
intent/constraints/decisions that code cannot express, and generates the whole harness:
CLAUDE.md / AGENTS.md, the docs/ set, and a per-module AGENTS.md. The harness spec is in
references/harness-format.md.
migration is a one-time conversion, not a task runner. It writes documentation only — it does
not create a 3-doc (that is ready's job) and does not execute code (that is go's).
After it finishes, commit the harness and clear the session before running ready → go:
migration is an independent piece of work, and a fresh session keeps the task-level dialogue clean.
Core principles (apply throughout)
- The harness is durable project memory, not ground truth. It is the project's discipline and constraint — written so the next agent works the project without going off the rails. A hollow harness (structure present, content empty) is worse than none.
- Content density is the whole point. Every file must clear the quality bar in
references/harness-format.md(five principles, four techniques). Filling sections is not the goal; informing the next agent is. - Knowledge asymmetry drives elicitation. Domain knowledge lives with the user — extract it (don't fabricate). Technical knowledge lives with you — present options + trade-offs and let the user decide. Don't accept the user's generalities as-is, and don't concretize them alone.
- Subagents only at the final REVIEW. SCAN, ELICIT, and GENERATE run inline in the main session —
generation needs the live conversation's raw grounding, not a summary. REVIEW is the exception:
the finished harness is verified by one independent subagent that did not author it. Self-judging
your own harness is the weakest move (A=A), and the harness is the most
durable artifact in the system (every later agent works inside it), so it earns the one fresh-eye
check — the same relaxation
readymade (generate inline, verify independently). This is the only dispatch. - Stack-agnostic. No stack/framework/library name in this skill. Discover all specifics (conventions, module boundaries, build/verify commands, external deps) at runtime from the project.
- escalate-don't-guess. What the code can't settle and you can't derive, ask the user — never invent a domain rule, a policy, or a rationale.
- Match the user's language (language-agnostic). Like stack-agnosticism, the method is fixed and the specific language is discovered at runtime, never assumed: produce every user-facing output — the dialogue and the whole harness (CLAUDE.md / AGENTS.md, docs/, module AGENTS.md) — in the language the user communicates in, written natively (as a fluent speaker of that language would, never translationese). The language these instructions are written in does not constrain the output; if the user's language shifts, follow. Hold it from the very first line, continuously — never open in the codebase's or these instructions' language and switch later. The language of the code you read does not constrain your output; only the user's does.
- Talk to the user only when needed — between beats, say nothing. You speak at exactly these
moments: (a) a question you genuinely need answered, (b) the final walk-through / result, (c) a real
blocker — these are the only times user-facing text exists. SCAN, GENERATE, REVIEW, and any fix
loop are silent phases: the UI already shows the file/command activity, so narrating it is pure
leak. If what you are about to emit is none of (a)/(b)/(c), the correct output is nothing.
Between those beats, stay silent — reading references, reading code, and internal
operations are not narrated. No transition lines ("now I'll...", "먼저 ...", "let me read...", "Now the ..." announcing each write) — at
those plumbing moments your voice slips into the instructions' language (English) or internal tokens;
emit nothing there, don't translate it. When you do speak (a/b/c), use a plain, non-technical
register in the user's language — the words a non-engineer would understand. This is your default
voice, not a per-line check, so it costs nothing. Never surface internal tokens: dryforge mechanism / coined terms (harness,
ledger, decision surface, grounding, lens, invariant,
.dryforge), phase / step labels (SCAN / ELICIT / GENERATE / REVIEW), or project-internal jargon a non-engineer wouldn't recognize (library/tool names, config flags, test-framework internals). Don't soften internal logic into user-ish words — just omit it. E.g. "Starting a git repo here." — not "Initializing git and adding the marker directory to.gitignoreso the harness state isn't committed."
Input & preconditions
- Invocation: the user invokes the
migrationskill, no arguments — migration reads the current project. - Existing codebase expected. migration converts a project that already has code. For a
greenfield project (no code yet), there is nothing to migrate — direct the user to
ready(which designs the project's first cycle and letsgocreate the harness from scratch). - git required. If the project is not a git repo, offer to run
git initand make an initial commit (latergoneeds a HEAD for worktrees). If git is not installed, stop and say so. - git posture — migration writes files, it does not commit. migration creates the harness files,
backs up any existing entry file to
.dryforge/backup/, adds.dryforge/to.gitignore(so the local marker and backups aren't accidentally committed), and writes the.dryforge/status.jsonmarker on completion. It performs no commits and no branch operations — whether and when to commit the harness is the user's choice. (This differs fromready, which never touches.gitignore: migration may not be immediately followed bygo, so it sets up the ignore itself.)
Phase 1 — SCAN (build the technical map)
Read the project inline (file reads, shell, search — no subagent dispatch). Start with the cheapest map and stop once you can ground ELICIT's questions; deep-read only where you must.
Cover:
- Directory structure → identify the tech stack and the module/service boundaries.
- Code patterns → conventions, naming, test structure, build system.
- Existing docs (CLAUDE.md, README, docs/, AGENTS.md, ...) → list them and demote to reference material (not authority — they may be stale or wrong).
- External dependencies → auth, data storage, cache, external APIs.
- git history → activity scope, the major change patterns.
Result: a manifest of the project — every module/entity, pattern, security surface, external
dependency, and gap. This is the ledger ELICIT works from (references/migration-elicit.md): each
item must close as confirmed / asked-answered / N/A — reason, so coverage is observable, not
asserted.
Phase 2 — ELICIT (collect what code can't reveal) — references/migration-elicit.md
Force-load references/migration-elicit.md. Using the SCAN map, ask the user for the
information code alone cannot extract — project-wide (not task-focused). The guiding frame:
self-infer first, ask deeply only where being wrong is dangerous (business model, domain
invariants, security policy must be user-confirmed even when code-inferable; technical WHY and
conventions need only a light confirm when the code answers them).
Existing-docs handling. Read existing docs (reference status). Review any existing CLAUDE.md/AGENTS.md critically — decide what to fold into the dryforge system, what to drop, and what to improve — then present the review to the user, explain it, and get approval.
Phase 3 — GENERATE (write the harness) — references/harness-format.md
Force-load references/harness-format.md and generate the whole harness to its spec, in order:
- Create the
.dryforge/directory if absent. - If a CLAUDE.md or AGENTS.md exists, back each one up to
.dryforge/backup/(entry-point handling in harness-format). - Create
docs/and every file in it (harness-format spec). - Create CLAUDE.md / AGENTS.md (identical content).
- Create a module AGENTS.md per module identified in SCAN.
- Record the current state in
docs/tracking/status.md(done vs. remaining, against full scope).
Explore sources fully before writing; verify each file against the code both ways (omission / hallucination) as you go — this self-check is separate from Phase 4.
Write every file silently — do not announce each file or section as you go ("Now the docs...", "이제 모듈 AGENTS.md를...", "Now the entry point"); the UI already shows each write. This multi-file writing sequence is where narration leaks most — emit nothing between writes.
Phase 4 — REVIEW (verify quality) — references/harness-review.md
Force-load references/harness-review.md (the rubric) and dispatch a fresh general-purpose subagent
that did NOT author the harness to verify it independently. Use a general-purpose agent with full
read/inspect tools (not a plan-only or search-only agent type) so it can cross-check every claim against
the actual code; give it the harness files + the rubric + the user's language (so it judges native
fidelity) + the Phase-2 ledger with every disposition, inline in the dispatch prompt (the ledger
is session state — the subagent cannot see it any other way, and the shared rubric does not carry
it), read-only, returning a structured list (no raw dump). It checks the four dimensions: content (substantive
density + quality principles), format (self-containment, altitude, no references), completeness
(required files present + every SCAN-ledger item dispositioned — judged against the inline
ledger), source-cross-check
(omission vs. hallucination, future-scope exempt). The subagent is a fresh session and cannot ask the
user — so the orchestrator relays each finding: internally resolvable → fix directly; needs user
intent → carry to Phase 5. A surviving blocker → escalate to the user, do not loop (the
3-doc-gate discipline). This independent pass is distinct from the author's own omission/hallucination
self-check during GENERATE (that catches what you can see; this catches what you can't — A=A).
Phase 5 — USER GATE
Present the whole harness to the user — not a raw document dump, but a walk-through of the key decisions captured (what SCAN/ELICIT found, what each doc records, what was dropped from old docs and why). Resolve any Phase-4 questions that need user intent. On approval:
- Write
.dryforge/status.jsonwith the initialized marker —{ "initialized": true }. This is a local-only marker (inside the gitignored.dryforge/): its presence tells a latergothat the harness already exists, so every change is a delta; its absence means first-cycle creation. - Confirm
.dryforge/is in.gitignore.
Then migration is complete. Remind the user to commit the harness (migration itself does not
commit — and a later go treats uncommitted files other than .dryforge/ as foreign work and
stops), then clear the session before running ready → go.
Completion gate (avoid self-judgment A=A)
Done only when ALL hold:
- Every
docs/file exists (7 core docs + tracking: status.md, decisions/index.md + an ADR (NNNN-*.md) for each trade-off decision the ledger confirmed, findings.md). - CLAUDE.md and AGENTS.md both exist, with identical content.
- An AGENTS.md exists for every identified module.
- The independent REVIEW passes (no blocking finding under
references/harness-review.md; any surviving blocker was escalated to the user, not looped). - The user has approved.
.dryforge/status.jsonwritten (initialized) and.dryforge/is gitignored.
ready
Reply in the user's language, and hold it continuously from your very first line — including the opening, any setup/git note, and progress notes, not only the questions and the 3-doc. Write natively (never translationese). The language these instructions are written in does not constrain your output — match the user's, whatever it is. Full rule in Core principles below.
The front door of dryforge. Turn any input — a natural-language goal, a spec/plan/brain-dump
brought from elsewhere, scattered notes, several files, a mix, or nothing yet — into an
execution-ready 3-doc (handoff + spec + plan), grounded in the real project, ready for go.
The input is material, not ground truth. Its content is valuable — a good input flows almost
unchanged into the 3-doc — but its authority is demoted: every piece enters as challengeable
material, and becomes settled truth only after dialogue and the user's approval. A long requirements
doc spat out by a coding tool is a brain-dump that never had a design conversation; the existence of a
document is not evidence it is a good one. Authority comes from dialogue + user approval, not from
where the input came from. The 3-doc contract is in references/output-format.md.
Core principles (apply throughout)
- Serve the spec. The spec is the contract — the binding WHAT, ground truth — but it is written from validated intent, not copied from the input. The plan is a provisional blueprint that realizes it (revise freely). Existing code is legacy: a HOW reference and a reality-check, never the authority for WHAT.
- Ask, don't assume — but don't ask the derivable. Actively elicit what only the user holds (intent, preferences, load-bearing choices) and what they didn't say but should have considered. What the input/code/harness settles, resolve yourself. Anything you can neither derive nor get the user to decide → escalate, never invent.
- Conflicts and unknowns → ask, never self-resolve. Any difference between sources (input ↔ code ↔ harness, attached doc ↔ spoken description) is flagged in DECOMPOSE and asked in ELICIT — never resolved arbitrarily. Self-filling a conflict is the origin of drift.
- ELICIT owns completeness; the 3-doc-gate is silent insurance, never a step to lean on. Elicit as if the gate does not exist. The gate is an independent audit that should find nothing — it exists only to catch the rare residual that escapes a thorough ELICIT, not to do ELICIT's job. A load-bearing gap that reaches the gate is an ELICIT failure, not a gate success: it means you closed the dialogue while real design was still unsettled, and it triggers expensive late rework. Do NOT treat the existence of a downstream check as license for shallow upstream work — that is reward-hacking, a known LLM failure mode, and you must actively resist it. Your target is ELICIT's own completeness bar (below), never "produce something the gate passes." Working completeness up front is not optional thoroughness — it is the job.
- Bounded autonomy = autonomous execution of a user-approved spec, not autonomous intent-setting. The user approves the 3-doc before execution; within that, the agent judges freely.
- Floor, not ceiling. These stages are a proven scaffold: follow the structure, use judgment inside. Do not hardcode question lists or verification checklists.
- Stack-agnostic. No stack/framework/library name in this skill. Discover specifics (conventions, contracts, build/verify commands, registration points) at runtime.
- Subagents only at the two independent checks. Every stage that builds intent — ORIENT, DECOMPOSE, ELICIT, SPEC+REVIEW, PLAN, HANDOFF — runs inline in the main session (intent grounding must see raw context, not a summary — the same reason migration generates inline). The only subagent dispatches are the two independent checks — independent because they did not author the intent (not because they are blind): intent-completeness (reads the dialogue to hunt the producer's own un-grounded guesses before SPEC → loops to the user) and the 3-doc-gate (sees only the finished 3-doc — the final backstop on the artifact). Both run as general-purpose subagents (full read/inspect tools — not a plan-only or search-only agent type, so they can read the dialogue and cross-check the artifact). Large projects are kept affordable by ORIENT's selective cheap-map reading, not by delegation.
- Harness-aware, two modes (cycle is the only branch). The entry branches on one fact:
.dryforge/status.json. Delta (present): load the harness (CLAUDE.md/AGENTS.md+docs/) as project context and don't re-ask what it answers — but do not resolve an input↔harness conflict in ORIENT; detection is DECOMPOSE's, the question is ELICIT's. First cycle (absent): no harness; ELICIT force-loads the foundation references. ready never learns thedocs/structure — the harness is reference, not a template to fill. (Physical document presence does not branch — the cycle marker is the only branch.) - Match the user's language (language-agnostic). Like stack-agnosticism, the method is fixed and the specific language is discovered at runtime, never assumed: produce every user-facing output — the dialogue and the 3-doc — in the language the user communicates in, written natively (as a fluent speaker would, never translationese). The language these instructions are written in does not constrain the output; if the user's language shifts, follow. Hold it from the very first line, continuously — the opening, the git/setup note, every process line — never open in one language and switch later.
- Talk to the user only when needed — between beats, say nothing. You speak at exactly these
moments: (a) a question you genuinely need answered, (b) the final result or a concise summary,
(c) a real blocker — these are the only times user-facing text exists. If what you are about to
emit is none of (a)/(b)/(c), the correct output is nothing. Between those beats, stay silent.
Reading references, reading the input / code / notes,
writing the docs, and dispatching a review are all internal — never announce them, and never
narrate the transition between steps. No transition lines — "now I'll write the plan", "먼저 양식을
확인하고", "let me read the guide", "Now I'll dispatch the review", "Now the spec..." (announcing each
document as you write it) all leak. (Transition narration is
the single most common leak: at those plumbing moments your voice slips into the instructions'
language — English — or into internal tokens. The cure is to emit nothing there, not to translate
it.) The user sees the beats, never the plumbing between them. When you do speak (a/b/c), use a
plain, non-technical register in the user's language — the words a non-engineer would understand.
This is your default voice, not a per-line check, so it costs nothing.
Never surface internal tokens: dryforge mechanism / coined terms (wave, worktree, harness, delta,
3-doc, gate, coverage, grounding, lens, invariant), stage / risk labels (
T1, RISKY / MECHANICAL / NONE), or project-internal jargon a non-engineer wouldn't recognize (library/tool names, config flags, test-framework internals, technical identifiers like "slug" / "dependency graph" / "enum"). Don't soften internal logic into user-ish words — just omit it. E.g. "Starting a git repo here." — not "Since go will later need git for worktrees, I'll initialize one (non-destructive setup)."
Input & preconditions
- Invocation: the user invokes the
readyskill. The input may be a goal, file path(s), prose, a mix, or empty. If it is empty or only says to use the skill, ask what they want to build or change. - git required. If the project is not a git repo, offer to run
git initand make an initial commit (an empty repo has no HEAD, so go could not create a worktree later). If git is not installed, stop and say so. This holds for both greenfield and existing projects — code presence is not the deciding factor. - Output location. The 3-doc is written to
.dryforge/at the project root as plain files. You do not touch.gitignoreand do not commit anything —goowns all git mechanics. Keep the produce=plan / run=do boundary: produce writes documents, run touches git.
Stage map + cycle-conditional reference loading
Run the stages in order. Force-load each stage's references at that stage (silently — reference
loading and subagent dispatch never produce user-facing text); [first]+ rows load only
in a first cycle (status.json absent). The cycle branches scope and conditional loading only — the
stage sequence is identical for first and delta.
Core principles inline (subagents only at intent-completeness + 3-doc-gate) · understand-not-guess ·
stack/language-agnostic · conflict→ELICIT · floor not ceiling · user-language native
ORIENT absorb input + ground code/harness · branch on status.json (no refs)
DECOMPOSE decompose.md · grounds-gate.md
ELICIT elicitation.md · gap-analysis.md · intent-review.md · grounds-gate.md
[first]+ project-scoping.md · project-design-domain.md · project-design-technical.md ·
first-cycle-review.md · foundation-format.md
intent-completeness intent-completeness.md ← independent guess-hunt → loop to user (subagent)
SPEC + REVIEW(A) output-format.md · review-fidelity.md [first]+ foundation-format.md
PLAN output-format.md · dependency-calc.md · example-3doc.md
HANDOFF output-format.md [first]+ foundation-format.md
3-doc-gate 3-doc-gate.md [first]+ first-cycle-review.md
← independent dispatch (the final backstop)
USER GATE (the one human checkpoint)
ORIENT — absorb · branch · ground
Take the input raw, decide first-vs-delta, and read code/harness inline to lay the context later stages stand on. No judgment or resolution here — classification is DECOMPOSE's, conflict questions are ELICIT's. Everything ORIENT produces is context, not a conclusion.
- Check git. Not a repo → offer
git init+ an initial commit. git not installed → stop and say so. Greenfield or existing, git is required. - Absorb the input lightly — capture its character only. Parse the argument tokens: resolve to
files where they are paths, read as prose otherwise, accept a mix. Empty / "use the skill" → ask
what they want to build or change first (that answer becomes the input; git from step 1 already
holds). Load what you read raw — do not summarize (it is the ore DECOMPOSE will deconstruct).
Capture the input's character: the rough conception, task type (greenfield / feature / refactor /
docs-config) and blast radius, and what the input points at (paths, entities, feature names — for
aiming grounding). Stop at character (type / scale) — assigning each piece to an axis is
DECOMPOSE's job, not ORIENT's.
- Low-blast downshift. A low-blast, no-new-contract goal (a one-line change, a docs/config edit, a refactor with no new behavior) → keep the later dialogue light; don't over-interrogate intent that isn't there. Still emit a VALID 3-doc: every section present, gates met, just thinner.
- Large input. "Load raw" means preserve the original losslessly and keep it quotable, not paste a huge file into live context. For large/multi-file input, keep an index and read section-by-section — don't kill signal by summarizing, but don't ingest it all at once either.
- Branch on the cycle.
.dryforge/status.jsonpresent → delta: load the harness (CLAUDE.md/AGENTS.md+docs/) as project context — load only; do not ask or resolve an input↔harness conflict here (DECOMPOSE catches it, ELICIT asks it). Absent → first cycle: no harness; ELICIT will force-load the foundation refs.- Safety guard (no marker but a harness on disk). If
status.jsonis absent but a dryforge harness already exists on disk (an entry file (CLAUDE.mdorAGENTS.md) with the harness navigation structure + a populateddocs/), do not assume greenfield — stop and ask whether to treat it as existing context (delta) or regenerate (first cycle). Don't guess (same as go's clobber guard).
- Safety guard (no marker but a harness on disk). If
- Ground the code (inline, optional). If code exists, read the cheapest map first — repo instructions, file list, manifests, verify scripts, the directories the input points at. Stop broad reading the moment the completion bar is met (inline ≠ "read everything" — suppress flooding). Deep-read only the contract to preserve, one representative HOW pattern, and the verify commands. Greenfield → minimal or skip. No subagent.
- Find the verify command. Discover the project's verify command. If none, surface that absence as a decision (a custom check / named human-approval evidence / "no automated gate") — recorded in SPEC, never left implicit.
Completion bar: input is loaded raw and the cycle is decided (+ delta: harness loaded); existing → you can state the goal's blast radius, the contract to honor, and the verify commands; greenfield → you have a grounded conception.
DECOMPOSE — deconstruct the input — references/decompose.md
Force-load references/decompose.md and references/grounds-gate.md. Break the input's content
into material ELICIT can use: classify each piece by axis (a fragment may file under several —
classification is not partition; when unsure, duplicate); convert premature code to a behavioral
contract and keep the verbatim snippet alongside it where it carries a load-bearing edge (keep-bias:
a dropped nuance is unrecoverable, an over-kept block is cheap); preserve non-derivable forms verbatim;
dedup wording but treat repetition as an importance signal, not redundancy; flag — never resolve —
every source difference; write a presence map per axis with a non-scoring form marker (bare
mention vs stated-with-rules) so ELICIT never reads "touched" as "covered". Do not judge (no
conflict resolution, no gap scoring) — but "don't judge" is not a license to skim: ELICIT does
not re-mine the raw INPUT, so signal you skip here is gone (same reward-hack ban as ELICIT). Meet
the DECOMPOSE exit bar (decompose.md) before leaving. The output is challengeable material; the spec
is written fresh from the dialogue, not from the input.
ELICIT — realize the user's intent — references/elicitation.md
Force-load references/elicitation.md, references/gap-analysis.md, references/intent-review.md,
references/grounds-gate.md. First cycle additionally: references/project-scoping.md,
references/project-design-domain.md, references/project-design-technical.md,
references/first-cycle-review.md, references/foundation-format.md.
The heart. One job: realize the user's intent — understand the user deeply enough that the spec is
their design. The discipline under every decision is understand vs. guess (elicitation.md): a
load-bearing decision is either grounded in the user (they said it / it follows from what they said +
the model you've built of their goal·values·constraints / they chose a presented option) → realize it;
or it is a stranger's guess → forbidden, close it. There is no "pick a reasonable default and
move on" for a load-bearing decision — that is the failure that detonates downstream (the agent
deciding what the user would have decided differently).
Method by knowledge location (two ways to not-guess, interleaved): domain/behavior → EXTRACT (the user knows; draw it out, never invent); technical → PRESENT (the agent knows; options + trade-offs + recommendation, grounded in the extracted domain; the user decides — never silent). Build and maintain a model of the user (goal / values / constraints / domain facts) and test each load-bearing decision against it: grounded → realize; model-silent → that is the gap, close it.
Scope by cycle — first establishes the foundation, delta works within it; both EQUALLY rigorous (delta is not "lighter").
- First cycle (no harness): a forced foundation design. Run
project-scoping.md(CALIBRATE: character → depth), then the domain extraction (project-design-domain.md) and technical presentation (project-design-technical.md). Their floors are non-negotiable, not loop-optional: the domain breadth guard (can't close without "are there other entities/features/rules?"), the domain depth floor, the technical no-silent-decision rule. These force understanding over guessing while the foundation is laid — do not dilute them. Scope = project foundation + this task; produces the Foundation 4 sections. - Delta (harness exists): do not re-run foundation design (read the floor from the harness; don't re-ask what it answers) — but realize this task's load-bearing intent with the full "no guess survives" discipline. Scope = this task; rigor = full.
Account the decision surface — enumerate, don't wait to be told (elicitation.md). Name the
entities (a manifest), then walk four lenses over each entity and colliding pair to enumerate the
load-bearing decisions the design is obligated to answer: STRUCTURAL (cardinality/composition/
identity), BEHAVIORAL (lifecycle/concurrency/policy/edges — name the kind first), TECHNICAL
(persistence/interface/consistency), CONTRACT (status·enum sets/uniqueness/output keys). Lenses
are accelerators, not a fixed catalog. Enumerate ≠ ask: resolve each slot in order — user-model
grounds it → realize (don't ask); tuning value inside a settled mechanism → default marked tunable
(don't ask); else assumed → ask (extract/present). So enumerate exhaustively but ask
minimally (≤4 questions·options per structured prompt, lead with a recommendation, grounds-gate.md
filters; never skip a load-bearing one; if the structured tool fails, re-ask as plain text — never
dead-end). First cycle / unfixed stack: you MUST have presented the load-bearing technical shape
(persistence, interface, and the concurrency/consistency model when the domain has shared state) —
a stack pick alone does not settle it.
Exit bar (observable) — write the spec only when no assumed slot survives (full bar in
elicitation.md): the surface is accounted — every load-bearing slot is grounded, deferred-tunable,
or asked-and-answered (a mechanism's preference-values, not just its yes/no, included); first-cycle
foundation floors met; no material gap remains. A thin input raises the bar (ask more), never lowers it.
intent-completeness — independent guess-hunt before SPEC — references/intent-completeness.md
Force-load references/intent-completeness.md. Before freezing the spec, dispatch a fresh
perspective that did not author the intent (independent — but it reads the chat session + the
decision surface; A=A distrusts authoring, not seeing) to audit the surface: (1) is each
grounded/deferred disposition defensible from the dialogue, or rubber-stamped? (2) walk the lenses
independently — is there an obligation-slot the producer never enumerated (e.g. an entity's
cardinality settled silently)? It does not flag tuning values (executor inference, not guesses).
Each finding is relayed to the user and closed by extract/present (not patched into a document);
bounded local re-walk of only the touched neighborhood, re-check once, then escalate — no open
loop. This catches guesses while the user is still here to decide, so the final 3-doc-gate finds
little. (This and the 3-doc-gate are the only subagent dispatches.)
SPEC + REVIEW(A) — write ground truth, verify fidelity — references/output-format.md
Force-load references/output-format.md and references/review-fidelity.md (+ first cycle:
references/foundation-format.md).
- Write
.dryforge/spec.md— from the validated intent, not the input. Dense; premature implementation excluded. The item list isoutput-format.md's contract — it owns the list; follow it there (if ORIENT found no verify command, record that gate decision in the spec's required-verification item). - First cycle — write the Foundation too, into
handoff.md. Write ELICIT's Foundation 4 sections (identity / domain / technical / future) intohandoff.md's Foundation section now (the rest of the handoff's governing parts wait for the plan and are filled at HANDOFF; the Foundation does not depend on the plan). No separate.dryforge/foundation.md. Into the spec, lift only this task's WHAT (the part of the domain this task actually implements); the project-wide context (the rest of the domain, future scope) stays in the Foundation. (Written here so REVIEW(A) can verify a written Foundation.) - REVIEW(A) — fidelity only, inline. Check that what the session settled landed in the document
without evaporation or distortion (+ first cycle: the written Foundation). Internally resolvable →
fix the spec; a user-only intent-gap → reopen ELICIT for that gap only (the one mid-run user
question). Completeness is not checked here (
review-fidelity.md— A=A): ELICIT owns it upstream, intent-completeness audits it independently, and the 3-doc-gate is only the final insurance. Gate: zero blocking fidelity gaps; no user-only intent-gap remains.
PLAN — decomposition for parallel execution — references/dependency-calc.md
Force-load references/output-format.md, references/dependency-calc.md, references/example-3doc.md.
Write .dryforge/plan.md from the frozen spec. Per task: a behavioral contract (goal, work
targets [files | state | external], verification gate), thinking-base where not code-derivable,
shared-write guidance (prose). Compute the Execution Graph last — a fenced yaml block with
depends (the only encoded judgment), regen_barriers, and the optional per-task risk using
exactly the enum RISKY | MECHANICAL | NONE (never an ad-hoc value like "high"/"low"). go follows
it and never re-judges. Scaffold is
not a task. (Any task-order/dependency graph the input carried was discarded in DECOMPOSE; PLAN
always computes the graph fresh from the spec.) Trace gate: every
spec requirement maps to ≥1 task (forward); every task grounds in a spec requirement (no orphan); the
Execution Graph parses.
HANDOFF — governing doc + assemble — references/output-format.md
Force-load references/output-format.md (+ first cycle: references/foundation-format.md).
- Write
.dryforge/handoff.md— the governing doc. The item list isoutput-format.md's contract — it owns the list (document roles + conflict resolution, file locations, execution shape, hard gates, uncaptured intent). (Because produce captures intent directly, this handoff is richer.) - First cycle — the Foundation is already written (at SPEC); here, fill the governing parts around
it. HANDOFF does not originate the Foundation — it assembles. Keep the Foundation clearly
labeled "Non-executable project context," separated from the governing parts, so
gonever mistakes a hard gate for project context. Delta: there is no Foundation. - Write the 3-doc to
.dryforge/— do not touch git. Do not touch.gitignoreand commit nothing (goowns git; produce=documents / run=git). If an input file is an untracked file inside the repo, advise the user to move it out or add it to.gitignore(produce does not delete the user's input itself).
Completion bar: handoff written (+ first cycle: Foundation assembled), the three files in
.dryforge/, git untouched.
3-doc-gate — the final backstop — references/3-doc-gate.md
Force-load references/3-doc-gate.md (+ first cycle: references/first-cycle-review.md). Dispatch a
fresh subagent that has not seen the dialogue; give it the 3-doc only (it may read the code),
read-only, returning a structured list (no raw dump). A single holistic review — executability
(aim explicitly at the output/interface contract), plus, first cycle only, a foundation-sufficiency
lens within the same review (first-cycle-review.md rubric on the written Foundation — not a
second dispatch). It is the final backstop and should find little, because intent-completeness
already routed the guesses to the user. Empty → the user gate. A blocker → the orchestrator relays it to the user,
fixes only the stage it belongs to, then re-runs the gate; a surviving blocker → escalate. (The machine
0-signal gates — coverage gap, orphan, graph parse — are cheap; keep them in place.)
USER GATE — the one human checkpoint
Present the completed, verified 3-doc to the user: "Review this and confirm. If it's right, proceed;
if not, tell me and I'll fix." On approval, tell the user to invoke the go skill in this
session to execute. Autonomy is executing an approved spec, not setting intent — one gate, at
the end (outside ELICIT's dialogue and the intent-completeness loopback, the only mid-run exception
is the REVIEW(A) reopen). Produce → run is one session — the design
context carries into go — but the 3-doc, not the dialogue, is the authority (it is archived and
read by later cycles, so it must be self-sufficient).
Completion gate (avoid self-judgment A=A)
The target you work toward is the ELICIT exit bar (no guess survives on a load-bearing decision) (above) + the deterministic 0-signals — that is what "done" means. The 3-doc-gate is a separate independent audit you should expect to pass with nothing found; it is not the bar you aim at, and you never do shallow work expecting it to catch the rest (reward-hacking — Core principles).
Done only when ALL hold:
- ELICIT completeness bar met: every load-bearing dimension the domain implies was surfaced to the user and settled (or explicitly marked N/A with a reason) — recorded in the spec, not left for the gate to discover.
- Deterministic 0-signals: coverage gaps = 0, orphan tasks = 0, Execution Graph parses.
- 3-doc-gate clear (insurance): the independent fresh subagent returned no blocking item. A finding here is an ELICIT failure that escaped, not a normal step — fix the stage it belongs to and treat it as a signal you closed the dialogue too early; residual → escalate to the user, never self-fill.
Sponsors
Details
- Marketplace
- prekuter/dryforge
- Source
- claude
- Author
- prekuter
- Category
- Community
- Keywords
- agent-harness, harness, bounded-autonomy, plugin, coding-agent, claude-code, codex, copilot, intent, elicitation, spec, planning, brainstorming, verification, autonomy