The Pull Request Was Clean. The Ticket Was Not.
A ready ticket is the API later stages read, and a comment-only reviewer plus one named human gate is what keeps agents from building a confident guess.

Plan turns an agreed need into a ready ticket an agent can build from, and a person still has to say it is right.
The clean pull request was never the failure; the ticket that let an agent guess the export was. A definition of ready, checked by a script and approved by a named person, is how you stop paying for that guess in review.
In this article: A vague ticket is a contract bug, not a model failure. Plan turns an agreed need into a ready ticket with a comment-only reviewer, one human gate, and a field list later stages only read.
A build agent takes "Add export for users" and guesses the rest: what, for whom, which format, which permissions. Two hours later a tested pull request exports every workspace the user can see. The app owner already ruled that out.
The model did good work on a bad input. Lucky teams spend a review cycle catching it. Unlucky teams ship it.
A factory ticket is not a note for a colleague. It is the contract for an agent that will not ask unless you force the question. Plan writes that ready ticket. Later stages read it. They do not call Plan.
A spec is not the unit of work
Spec-driven development puts a versioned spec, not the chat, at the center. GitHub Spec Kit, OpenSpec, AWS Kiro, and BMAD are examples of the same shape: spec, then plan, then tasks, then implementation. Swap them freely.
Thoughtworks and Birgitta Böckeler name three levels:

The three levels differ in how the spec relates to the code. The Level column names each one. What it means says how the spec and the code relate at that level. Good fit names the kind of work each level suits.
- Spec-first. You write the spec, generate from it, then let the code lead. It fits greenfield features and prototypes.
- Spec-anchored. Spec and code evolve together, under review. It fits most brownfield systems.
- Spec-as-source. You edit the spec, and the code is regenerated and disposable. It fits narrow domains with strong tests.
Existing systems should stay spec-anchored: the spec lives in the repo, changes are reviewed like code, and the ticket points at the section it implements.
Agents do not build specs. They build tickets. Claude Code plan mode, Codex, Superpowers, GSD, and Spec Kit can each emit a task list. One ticket store, one schema, and a link back to the plan. The reviewer sits at that door.
The ticket reviewer loop, one human gate
In one workshop repo the reviewer is the Ticket Enhancer. Its question: is this ticket a contract a machine can check?
Shrinks for the human: chasing gaps after work starts. Grows for the human: the definition of ready, and the named approval.

Trigger. Every create or edit re-runs the review, so it converges instead of going stale.
Work. What does done look like? How is it validated, and who reviews it? Are acceptance criteria testable? Are dependencies named? Does it link to the agreed need from Shape and any constraining ADR? Is anything outside the owner's scope?
Comments, not edits. Name the gap. Do not rewrite the ticket. People answer or edit, and the reviewer runs until nothing is open.

Human gate. Zero open comments is necessary, not sufficient. Ready requires a named "looks good to me." The agent may call the ticket complete. Only a person may call it right.
The model lists; a script decides. The model's "ready" is not the gate. The model lists fields. A script computes what is missing. Deterministic readiness is the cheapest gate in the factory.
Stop. If the same gap survives two rounds, stop commenting and ask the owner.

The workshop build is a Claude Code plugin, ported to Codex, OpenCode, Copilot CLI, the Claude Agent SDK, and LangChain Deep Agents. A poll, a cron job, a GitHub Action, or a webhook can run the same loop. The Ticket Implementer asks whether the work met the contract. Build reads the ready ticket. Plan does not call Build.
The ready ticket is an API
Plan writes the ticket. Dispatch reads it to choose what starts. Schedule reads dependencies for order. Build reads it for what to build. Shared artifacts, not function calls, are the interface, so the ticket needs one schema.
READY and Ready are different strings. Nothing errors. Flow stops, and a day can pass before anyone notices. Validate the vocabulary on write, the way you would an OpenAPI spec.

Each field of the ready ticket exists because a later stage reads it. The Field column names the field, and the Why the next stage needs it column says which stage uses it and for what.
- Link to the agreed need. Build uses it to check scope against what the owner approved.
- Acceptance criteria. These are testable statements. Build builds against them, and Review checks against them.
- Validation plan. It names which tests, checks, or demos prove the work is done.
- Dependencies. Dispatch and Schedule follow this graph from its base.
- Constraints. These are the linked ADRs and policies the build must respect.
- Ready decision. It records who said "looks good to me," and when.
Also record the risk tier, a one-sentence reason, the paths to touch, and the test evidence the pull request must show. Review then checks a written tier, not the author's summary.

GitHub Issues, Jira, Azure DevOps, or a git-native log can hold it. WikiTicket SDD (pronounced "wicked ticket") is one example: an append-only event log, comments and the human approval as events, links from plan to ticket to pull request, and a publish step into the tracker and wiki you already use.
Right-size the ceremony
Four stories, sixteen acceptance criteria, and an architecture review will kill support for a two-line fix. Heavy spec workflows pay off on complex features and add real overhead on small ones. Do not skip the reviewer. Shrink the definition of ready.
- Quick path. A reproduced bug, a copy fix, or a dependency bump. Check done, verification, and existing scope. One "looks good to me."
- Full path. A new feature, or security, data access, money, or a public API. Full fields, linked ADRs, and a named reviewer for the validation plan.
The reviewer may propose the path. A person confirms it. A "small fix" that touches access control must not be waived by the agent.

Memory, then the smallest start
Format checks need no memory. Substance checks do. Before commenting, recall the agreed need and its out-of-scope line, ADRs for the area, similar past tickets and what went wrong, and known failure patterns in that code. After ready, keep the thread's decisions. Trackers bury them.
Store work and knowledge apart. Tickets, events, and links stay in the ticket store. Decisions sit with the PRDs and ADRs. OKF's Project Knowledge Capture plugin is one writer for that second store. A wiki or a folder of decision records also works. People review those writes like code.
Claude Code, Cursor, and GitHub Copilot can bind a rule to paths. A tenant-isolation ADR then loads on the data layer and stays out of a React edit.
Evidence is medium: wide practice, no controlled studies. Cloudflare has described an agent that reviewed close to 600 designs before build. OpenAI checks plans into the repo. Treat both as operator reports, not audits.
Tools stay swappable: Claude Code plan mode, Codex, Superpowers, or GSD for the plan; Spec Kit or OpenSpec for the files; Kiro for EARS-style criteria; BMAD for PM and architect personas; WikiTicket for the log; your reviewer as a plugin or a GitHub Action.
Start comment-only, on issue events, with a read-only token, no shell, and no secrets. It cannot edit code or mark ready. Issue text is a proven prompt-injection path into CI agents, so read-and-comment is the small blast radius. From week one, count comments dismissed as noise. A high rate means fix the reviewer before any stage trusts ready tickets.
A fictional workspace export
The owner has approved a workspace-only export. The ticket says "Add CSV export of workspace data for admins."
Three gaps: no testable rule for a non-admin, no mention of the tenant-isolation ADR's workspace filter on every query, and no large-workspace validation plan. The lead fills the first two. The third becomes its own ticket, access checks, which the export depends on. A second pass finds nothing open. A named reviewer says "looks good to me" on both. The filter test exists before any code. Review will use that line, not the pull-request summary.
Further reading
- Wicked Ticket
- The Work Is Happening. You Just Cannot See It.
- Loop Engineering: The Git-Native Fishbowl
- Ticket Risk Tiers
- GitHub Spec Kit
- Definition of Ready, Microsoft Engineering Playbook
- Path-scoped rules
- AGENTS.md
Workshop code: reliable-agentic-lab. WikiTicket: wiki_ticket_sdd.
Do this today
- One definition of ready, validated on write: agreed need, testable criteria, validation plan, dependencies, constraints, and who said "looks good to me." One spelling per status.
- Comment-only reviewer, read-only token, no shell, no secrets. A script decides which fields are missing.
- Quick path for a reproduced bug, copy fix, or dependency bump. Full path for security, data, money, or a public API. A person confirms the path.
- Count noise dismissals from the first week before any later stage trusts a ready ticket.
Say it is right
The clean pull request was a guess the ticket allowed. Plan spends the argument in comments, while the change is still a paragraph.
A script can list a missing field. It cannot mean the work. If nobody owns the definition of ready, the agent that files the guess already does.
This is Part 3 of "AI Software Factory Series," a 17-part guide to building an AI software factory with human gates.