The sprint, phase by phase
/at-ship <goal> runs a whole sprint in one session: it maps the code, plans, builds, reviews, tests and writes down what it learned.
Each phase also has its own lead workflow, so you can run one phase at a time and read its output before the next. Watch one sprint on the home page, or run one yourself in Your first sprint.
Start a sprint
Claude Code leads
/at-ship <goal> Codex leads
$agent-triforge:at-ship <goal>Add --convergence fast or deep to change where the review stops, and --team to build as an agent team.
Phases
The phases run in this order, and the lead gives a reason for any phase it skips.
Phase 0: Analyze
Full-repo scan: architecture, patterns, contracts, debt
Antigravity reads the whole repository with the
codebase-analystagent definition. The lead skips the phase when the codebase has not changed or the change is a small fix. A failed run does not stop the sprint, which goes on without a freshops/ARCHITECTURE.md. Captured output is kept only when it is not empty and the run reported success.- Agents
- Antigravity CLI +
codebase-mapping - Analyst
- Antigravity, then Claude Code
- Writes
ops/ARCHITECTURE.md- Lead workflow
at-plan
Pre-plan
Search institutional knowledge for relevant past solutions, skipped while the store holds only the skeleton
The
learnings-researcherpersona searches the notes earlier sprints left for anything that bears on the goal, so a mistake one sprint wrote down is not made again in the next.- Agents
learnings-researcher- Reads
ops/solutions/ops/decisions/- Lead workflow
at-plan
Phase 1: Plan
Decompose the goal into tasks with shadow paths and error maps, grouped into waves
The lead follows
writing-plans, traces how each non-trivial task can fail withshadow-path-tracing, copies the types fromops/CONTRACTS.mdinto the task descriptions and groups the tasks into waves. Each task names the roster role that will do it.- Agents
- Lead +
writing-plans - Writes
ops/TASKS.md- Lead workflow
at-plan
Phase 1.1: Ambiguity
Surface the 3 most critical unverified assumptions and ask you to confirm or correct them
Each assumption comes with its other reading and what goes wrong if it is the wrong one. You confirm or correct them, and the lead revises
ops/TASKS.md. A goal with nothing open to question skips this step.Phase 1.5: Validate
Validate assignments, dependencies, scope and shadow paths, up to 3 rounds
plan-checkerreads the plan and returns a verdict, and the lead revises until it says APPROVED. Likesecurity-sentinelandfindings-synthesizer, it always runs on top-tier Claude, whichever CLI leads. Nothing is built from a plan it has not approved.- Agents
plan-checker- Writes
ops/TASKS.md- Lead workflow
at-plan
Phase 2: Build
Wave orchestration over leased builders, with integration verification between waves
Each task is leased from the roster and built in its own worktree. A pinned reviewer, a different roster member from the builder, checks it; after three fix cycles with the same reviewer, you decide. The lead squash-merges its own snapshot of the task, one commit per task, onto the sprint's integration branch, and
integration-verifierchecks that branch between waves. Promotion to your main branch follows[promotion]in the roster and waits for your approval when the change touches a protected path. With fewer than 5 independent tasks the build runs as sub-agents; with 5 or more, with interdependent tasks or with--team, it runs as an agent team.Phases 3 and 4: Review
Five lanes at once (Antigravity, Codex,
security-sentinel,performance-oracle,code-simplicity-reviewer), then synthesis with confidence tiers; up to 3 cyclesThe lanes start together, and each writes its own review file, so none waits for another.
findings-synthesizermerges the files and sets the confidence tiers; a lane that is missing or empty counts as a gap, and the cycle cannot converge on it. The lead fixes the P1 and P2 findings and records every finding as fixed, dismissed with a reason, or deferred with where it went.- Agents
- Antigravity + Codex + three review personas
- Writes
ops/REVIEW_*.mdops/TASKS.md- Lead workflow
at-review
Phase 5: Test
Gap analysis, tests written failing first, up to 3 fix cycles, then escalation to you
test-gap-analyzerfinds the paths in the changed files that no test covers. It sees committed work only, so when the changes are uncommitted the lead asks you to commit them or name a branch, and never commits for you. The tester writes each test so that it fails first, and the lead fixes and reruns until the suite passes.- Agents
- Codex CLI (
test_writer) - Tester
- Codex, then Claude Code
- Writes
ops/TEST_RESULTS.md- Lead workflow
at-test
Phase 6: Wrap
Document solutions, archive reviews, verify, write STATE.md, create
ops/.sprint-completelastknowledge-compoundingwrites a note toops/solutions/only when a future agent would repeat a mistake without it. The lead updates the changelog, memory and task files, archives the review files toops/archive/<date>/, runsverification-before-completionand writesops/STATE.md. The completion marker comes last, and only when the checklist below holds.- Agents
- Lead +
knowledge-compounding - Writes
ops/STATE.mdops/archive/ops/.sprint-complete- Lead workflow
at-wrap
Review until it converges
In at-ship, five lanes review the change at once. Each writes its own file, findings are ranked P1, P2 or P3 with a confidence tier, and a low-confidence finding is never P1. Each ends with a Coverage line, and one that reports less than complete, or omits the line, blocks convergence.
- AntigravityArchitecture and design.
- CodexLogic, security and tests.
security-sentinelReviews for security and nothing else: OWASP-class issues, in depth.performance-oracleFinds bottlenecks and scaling problems, such as nested loops over the same data.code-simplicity-reviewerFlags complexity the change does not need, like an interface with one implementation.
Then findings-synthesizer reads every review file, removes duplicates, sets confidence tiers and writes one report.
Where the loop stops
After each round of fixes the lead counts what is left. With --convergence you choose when that is enough; until then the reviewers go again, three cycles at most. After the third, the lead hands you the open findings, each reviewer's view, the dispositions and its recommendation, and you decide whether to ship with known issues.
| Mode | Stops when | Use it for |
|---|---|---|
fast | P1 count = 0 | Time-pressured, fix critical only |
standard (default) | P1 = 0 and P2 = 0 | Normal development |
deep | P1 = 0 and P2 = 0 and P3 < 3 | High-quality release |
Quality gates
Five gates hold at every stage, whichever workflow runs.
Plan validated
No build without a validated plan (max 3 iterations).
Enforced by
plan-checkerpersonaFailing test first
No production code without a failing test.
Enforced by
at-testworkflow, Codextest_writerRoot cause first
No fix without diagnosis.
Evidence first
No "done" without proof.
Enforced by
verification-before-completionskillReview first
No merge without code review (max 3 cycles).
Enforced by
at-reviewworkflow, which merges findings with thereview-synthesisskill
When a sprint is done
The lead creates ops/.sprint-complete in Phase 6, as its last action, and only when every item on the checklist holds. coordinate.sh reads that file and nothing else to decide that a sprint has ended. When an item fails there is no marker, and the blocker goes into ops/TASKS.md and ops/STATE.md.
Under Claude Code, the sprint prints the checklist as a /goal line at the start. /goal is an assist (probe CC-03 went 0 of 3 on Claude Code 2.1.318), and ops/.sprint-complete plus coordinate.sh decide completion. A Codex lead has no /goal and finishes on the marker alone.
The completion checklist
- Every phase is done (or explicitly skipped with a stated reason).
- The
verification-before-completionchecklist passes with evidence. ops/STATE.mdis written for session handoff.- Temporary review files are archived to
ops/archive/. - The runtime marker
ops/.sprint-completeis created LAST, only after 1–4 hold.
Run a phase yourself
In a supervised session you run each phase's workflow and read what it wrote before you start the next. at-plan covers Phases 0 to 1.5, and each later workflow takes one phase.
at-coordinate runs the same pipeline without the convergence and team flags; it is the cycle coordinate.sh drives across fresh sessions. Every lead workflow is on Workflows.
Claude Code leads
/at-plan <goal> /at-build /at-review /at-test /at-wrap Codex leads
$agent-triforge:at-plan <goal>$agent-triforge:at-build$agent-triforge:at-review$agent-triforge:at-test$agent-triforge:at-wrapType them one at a time, each after the one before has finished.