conducting-a-gate
Use when a delivery run reaches a human gate and someone must assemble the evidence, make the decision, and write the gate record — Gate 1 scope, Gate 2 design, Gate 3 release, or a case-specific vari
SKILL.mdskills/conducting-a-gate/SKILL.md
GitHubConducting a Gate
Overview
A gate is a named checkpoint where the run halts until a recorded human decision exists in
gates/. It is the framework's only hard stop. Everything else — handoffs, findings,
loop-backs — moves work between agents; a gate is where a person takes responsibility.
Two consequences follow, and both are routinely got wrong:
- A run waiting at a gate is not stuck. It is the framework working. Do not "unblock" it by proceeding.
- The record is the decision. A verbal approval, a chat message, or an agent's belief that
the approver would agree is not a gate. If
gates/gate-N-*.mddoes not exist and name a person, the gate has not happened.
The Orchestrator assembles evidence and halts. A human decides. No agent may sign a gate, and no agent may proceed past one on its own authority.
When to Use
- A run has reached a gate and the evidence needs assembling and presenting.
- You are the approver and need to know what you are actually signing.
- A gate came back
rejectedorapproved-with-conditionsand the run must resume correctly. - A mid-run scope change has arrived and you need to know which gate it re-opens.
Do NOT use for: informal checkpoints that gate nothing downstream by a signature — the
defect case's reproduction sign-off, for example. Those are confirmations, not gates, and
they produce no record.
Step 1 — Identify which gate, and which variant
The three standard gates are the greenfield set (agent-handoff-protocol.md §3.1):
| Gate | Fires after | Approves |
|---|---|---|
| 1 — Scope | Requirements Analyst | Requirements doc, glossary, every open question answered |
| 2 — Design | Architecture Guardian's clean review | Architecture, stack, integration inventory, cost-relevant choices |
| 3 — Release | Release evidence assembled | The production release itself |
A case may use fewer gates, or a variant (§3.4). Check your playbook's gates: frontmatter
first — the variant changes the trigger, the ordering, or the decision vocabulary, never the
requirement for a recorded human decision:
- Release — emergency/retroactive (
incident, active-exploitdependency-upgrade) — mitigation deploys first under documented emergency authority; the gate is signed retroactively against the logged action timeline. Addemergency_authorized_byand attach the timeline as evidence. No rigor is waived — regression, review, and the post-incident report still happen, only after restore. - Behavior-parity (
refactor) — one gate, two checkpoints: the characterization suite was captured all-green before any code moved, and is green and identical test-for-test after.approvedrequires both halves. - Data-operation (pre-execution) (
data-operation) — fires before execution. The approver signs the operation plan and the rollback plan together, with the dry-run diff attached. Post-execution verification is a closure condition, not a second gate. - Findings / decision (
spike) — accepts a decision/findings record.decision: accepted, no deployment, and no canonical promotion. - Release — baseline-approval (
brownfield-onboard) — approves a reconstructed baseline rather than a deployment; on approval the baseline is promoted to canonicaldocs/.
Step 2 — Assemble the evidence
The approver should not have to go looking. Assemble, from the run workspace:
- The artifacts under review, by path — not summaries of them.
- The clean review that qualifies the gate, where one applies (Gate 2 needs the Architecture Guardian's review to be clean, not merely to exist).
- Every open risk, with ID and severity. Risks are never deleted; they are resolved or formally accepted, and acceptance requires the approver's name.
- Every open question. For Gate 1 this is the substance of the gate — an unanswered question is an unapproved requirement.
- Verification output where the gate rests on it: test results, dry-run diffs, characterization suites, release evidence.
- Cost- and legal-relevant choices, surfaced explicitly. Gate 2 is where hosting, provider, and retention decisions become expensive to reverse.
A gate presented as "everything looks good" is not assembled. Name the paths.
Step 3 — Write the gate record
runs/<run-id>/gates/gate-<n>-<slug>.md, in the §3.2 format:
# Gate 2 — Design
run: 2026-06-comedor-mvp
decision: approved # approved | approved-with-conditions | rejected
approver: <name from packet §16>
evidence_reviewed:
- runs/.../02-design/architecture.md
- runs/.../findings/architecture/review-002.md (clean)
conditions: [] # binding; the Orchestrator tracks each as a risk
notes: ...
approveris a person named in packet §16. Not a role, not an agent, not "the team".evidence_reviewedlists paths, each annotated where its state matters ((clean)).conditionsare binding. Each one becomes a tracked risk that must be closed before Gate 3. An aspiration written intonotesis not a condition and will not be tracked.- The
spikevariant usesdecision: accepted.
Step 4 — Resume correctly
| Decision | What happens next |
|---|---|
approved |
The run proceeds to the next playbook step. |
approved-with-conditions |
The run proceeds; each condition becomes a tracked risk, registered in state.md with an ID, and must be terminal before Gate 3. |
rejected |
The run routes back to the producing agent, with the rejection notes issued as a new inbound handoff — not as chat. Re-review after the fix; the original gate record stands as history and a new one records the second decision. |
A rejected gate is not an edit to the existing record. Records, like handoffs, accumulate.
Step 5 — Handle a mid-run scope change
A scope change re-opens Gate 1 (§3.3). The flow is fixed:
packet amendment → Requirements Analyst delta review → Gate 1 re-approval
→ Bundle Compiler delta → Bundle Intake Validator
Three rules that get broken under time pressure:
- Never edit the frozen packet under
00-packet/. A scope change is an amendment file beside it. - Implementers never absorb scope changes directly from chat. A change that reaches an implementer without passing Gate 1 is untraceable by construction.
- A request too large for an amendment queues as the next increment run (§6.6). "Too large" is a judgement the approver makes, not the implementer.
What a gate is not
- Not a status meeting. It approves specific artifacts against specific criteria.
- Not an agent's decision. The Orchestrator halts and presents; it never signs, and it never overrides a reviewer's blocking finding without explicit human approval.
- Not retroactive — except the one variant that says so, in writing, with an authorizing name and a timeline.
- Not skippable when the run is "obviously fine". The obvious-fine runs are the ones where skipping becomes habit.
Checklist
- Correct gate and correct variant for this case's
gates:frontmatter - Every artifact under review named by path
- Qualifying review is present and clean, where the gate requires one
- Every open question answered (Gate 1) or explicitly deferred with a named owner
- Every risk ID listed with severity; accepted risks carry the approver's name
- Verification output attached where the gate rests on it
- Cost- and legal-relevant choices surfaced, not buried
- Record written to
gates/gate-<n>-<slug>.mdin the §3.2 format -
approveris a person named in packet §16 - Conditions registered as tracked risks in
state.md - Rejection routed back as a new inbound handoff, not as chat
Reference
process/agent-handoff-protocol.md— §3.1 standard gates, §3.2 record format, §3.3 semantics and scope change, §3.4 case variants, §6 closureprocess/playbooks/<case>.md— which gates this case uses and wheretemplates/stakeholder-input-packet.md— §16 names the approverresuming-a-runskill — reconstructing where a halted run stands