atdd-team

Team-Based ATDD Workflow

Orchestrate an agent team that follows the Acceptance Test Driven Development workflow. The team lead coordinates specialist agents through six phases. Each phase is run by a fresh agent invocation — no agent persists across phases.

Why fresh per phase

A long-lived agent's context compacts as a feature runs for hours. Compaction silently erodes role identity and discipline: agents lose their role, invent constraints that do not exist, and skip expensive-but-required steps. A fresh per-phase agent reloads its instructions clean — the same insight as the engineer plugin's per-skill model. The "team" exists for parallelism across features, not for keeping agents alive within one feature.

Team Detection

Before spawning phase agents, check for existing teams:

1. Read ~/.claude/teams/ to list active teams.
2. If a team exists, present the user with a choice:
   • Extend — run the ATDD phases for this feature alongside the existing team.
   • Replace — shut down the existing team and run ATDD fresh.
   • New team — run the ATDD pipeline as a separate team.

If no team exists, proceed directly.

Roles

Each phase is run by a fresh agent invocation scoped to that phase, then ended.

Role	Maps to	Owns phase
spec-writer	discuss, discover-acs, atdd spec step	1 Spec Writing
reviewer	spec-guardian agent	2 Spec Review
implementer	atdd impl, pipeline-builder	3 Pipeline Gen, 4 Implementation
refiner	the engineer plugin's refine skill	5 Refine
architect	consistency-check, crap-analyzer, atdd-mutate	6 Verify & Harden

The team lead (the orchestrating agent or user) owns the workflow, approves all work, enforces discipline, and verifies the agent_id independence binding. The team lead never delegates approval — specs are the team lead's contract.

Coordination rules

• Durable handoffs, not chat. Each phase ends by writing a handoff summary to features/NNN-slug/handoffs/ (the engineer plugin's handoff contract, with the exit_criteria block). The next phase's fresh agent reads the prior handoff for context — coordination survives a context compaction.
• Phase gate = checkpoint exit criteria. A phase is done only when its handoff asserts every exit criterion met (Foundation Design Section 8). Before starting a phase, verify the prior checkpoint is complete — run the engineer plugin's scripts/dae_handoff.py <feature-dir> --through <prior-cp>.
• agent_id independence (Principle 7). Each phase handoff records its agent_id. The architect's agent_id MUST differ from both the implementer's and the refiner's — the verifier verifies neither its own code nor its own refinement. The team lead checks this.
• Role boundary. The implementer takes the code to green only — it does NOT do deep refactoring; that is the refiner's phase. Every phase handoff states explicitly what was NOT done and what is left for the next role.
• Per-phase anchor. Each phase agent's spawn prompt embeds a reorient-style anchor: role, autonomy level, the prior handoff, the phase's exit criteria, and the non-negotiables. See references/prompts.md.