prekuter/dryforge / antigravity/skills/ready
ready
VerifiedUnderstand what you mean before anything is built. Takes anything — a one-line idea, notes, a spec, or a mix — reads the project first, asks only what is yours to decide, and writes your intent down for you to approve. Use when the user invokes the `ready` skill. Requires git.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 27.0 KB |
| references/3-doc-gate.md | markdown | 6.0 KB |
| references/decompose.md | markdown | 11.2 KB |
| references/dependency-calc.md | markdown | 6.1 KB |
| references/elicitation.md | markdown | 18.2 KB |
| references/example-3doc.md | markdown | 7.8 KB |
| references/first-cycle-review.md | markdown | 3.1 KB |
| references/foundation-format.md | markdown | 5.3 KB |
| references/gap-analysis.md | markdown | 4.7 KB |
| references/grounds-gate.md | markdown | 3.6 KB |
| references/intent-completeness.md | markdown | 6.3 KB |
| references/intent-review.md | markdown | 4.0 KB |
| references/output-format.md | markdown | 10.0 KB |
| references/project-design-domain.md | markdown | 4.4 KB |
| references/project-design-technical.md | markdown | 4.2 KB |
| references/project-scoping.md | markdown | 3.5 KB |
| references/review-fidelity.md | markdown | 4.6 KB |
references/3-doc-gate.md
View on GitHub# 3-doc-gate.md — the independent backstop
After the 3-doc is complete, a fresh subagent that has **not seen the dialogue** verifies it
independently — to structurally avoid the A=A trap where the author cannot see his own unknown
unknowns. This is **one of the skill's two** subagent dispatches — the other is
the earlier **intent-completeness** check; every other stage runs inline because intent grounding needs
raw context, not a summary (Core principles).
**This gate is insurance, not the completeness mechanism.** Completeness is owned and generated by the
ELICIT loop (`elicitation.md`); this gate exists only to catch the **rare residual** that a thorough
ELICIT still missed. **The expected outcome is that it finds nothing.** A blocking finding here is
therefore not a success of the gate — it is a **signal that ELICIT closed too early** (a load-bearing
gap reached the end instead of being asked in dialogue). It is never a substitute for elicitation, and
ready must never be authored to lean on it: an upstream that under-elicits "because the gate will
catch it" is reward-hacking (Core principles).
## Dispatch pattern (read-only, structured return, orchestrator relays)
Dispatch a fresh subagent in a session that has **not** seen the conversation. Pin these (required
elements, not a fixed script):
- **Scope** — give it the **3-doc only**. It *may* read the project code (that is what `go` reads at
run time), but not the dialogue.
- **Read-only** — it verifies; it does not edit anything.
- **Return contract** — a **structured list** of residual blockers/questions, not a raw dump. Each
item names its site and why it blocks.
- **Compactness** — keep the return small enough to live in the main context.
- **Report, don't fabricate** — it reports what it actually found; if the 3-doc points at something it
can't confirm, it reports *not found*, never invents a gap.
The subagent is a fresh session and **cannot ask the user directly** — so when it returns a blocker,
the **orchestrator relays it** to the user in plain words (no raw dump), gets the answer, and fixes.
## A single holistic review (executability; foundation as a first-cycle lens)
**One pass, not several.** Because the deep completeness work was done upstream by intent-completeness
(with the user), this final gate is a **single holistic review of the artifact** — not split into
separate deep dispatches. Ask: *"can this 3-doc alone execute the task — what would block, or what would
you have to ask?"*
Aim it at the **output / interface contract** — the data model's fields and constraints, response/
output keys, status/enum value sets (and whether two distinct fields were collapsed), uniqueness/
identity rules. But note the shift: the contract is now **pinned upstream** (ELICIT's CONTRACT lens +
SPEC's "write precisely as if no gate exists", `output-format.md`). So the aim here is a **fidelity /
consistency check** — is the pinned contract internally consistent and intact through transcription? —
**not** a place to *tighten* a half-pinned contract over rounds. A contract-precision gap surfacing
here is an **upstream failure** (ELICIT/SPEC under-pinned it), not work for the gate to grind out.
**The last uncorrelated look.** Both upstream checks can share a blind spot — ELICIT may never name an
entity, and intent-completeness's residual-enumeration audit (`intent-completeness.md`) can miss the
same one (correlated A=A). This gate is the one look at the *finished artifact* from yet another fresh
session, so it sometimes surfaces what two intent-stage looks missed: an entity, state, actor, or
interaction the domain implies that the spec never names. That is its real residual value. The
*grounding* hunt — decisions the agent guessed rather than grounded — was already done upstream by
intent-completeness, so this gate expects to find little.
## first cycle — add a foundation-sufficiency *lens* to the same review
In a first cycle there is also a written Foundation, so the **same single review** carries one extra
lens: **foundation sufficiency** — judge the written Foundation against `first-cycle-review.md` (domain
depth and breadth, technical decisions closed, security project-specific, zero vague modifiers). This
is a **lens within the one holistic pass, not a second dispatch.** (intent-completeness owns the deep
completeness work upstream, so the final gate's job is narrow enough to do executability + the
foundation lens in one review.) In a delta there is no Foundation, so this lens is simply absent.
## Process the results
- **Empty → pass to the user gate.**
- **Blocker present** → the orchestrator relays it to the user (no raw dump), and with the answer
**fixes only the stage that blocker belongs to**:
- a user-only intent-gap → reopen ELICIT for that gap only → update SPEC;
- a spec↔plan inconsistency or an under-pinned contract → fix only the relevant document
(SPEC / PLAN / HANDOFF).
Then **re-validate the fix** — the machine 0-signal gates always re-run (cheap, deterministic), plus
a bounded re-check of just the area the fix touched. **Do not enter a multi-round "tighten the
contract" loop:** if round after round keeps surfacing load-bearing or contract gaps, that is an
ELICIT/SPEC failure (the contract should have been pinned upstream) — **stop and escalate to the
user**, never converge a half-pinned spec via re-gating. A surviving blocker → escalate (same
discipline as REVIEW(A)'s reopen rule).
(Separate from this gate, the **machine 0-signal gates** — coverage gap, orphan task, graph parse —
are cheap; keep them in place everywhere. They are not part of this dispatch.)
## Gate (proceed to the user gate when)
The subagent returns **zero blocking items** (or they were resolved via user escalation), and the
machine 0-signals are zero.
## Universality guard
Stack-agnostic. Executability and foundation sufficiency are judged against whatever this project is,
discovered at runtime from the 3-doc and the code — no stack assumed, no fixed field checklist.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |