fleet-dotfiles-template/dot_claude/agents/agentic-team/team.md

name, description, version

name	description	version
Agentic Development Team	7-agent team for plan execution — 2 advisory + 5 implementation	1.0.0

Agentic Development Team

Prerequisites

An implementation plan must exist before this team is invoked. The plan is written by a separate set of planning agents with user feedback. This team validates and executes the plan.

Phases

Phase 1: Advisory (parallel)

Run Explorer and Critic concurrently. Both read the implementation plan.

Agent	Input	Output	Runs
Explorer	Implementation plan	Research brief, version manifest, innovation token audit	Once, before implementation
Critic	Implementation plan	Concerns list, ambiguity register	Once, before implementation

Gate: Advisory phase completes when both agents have produced their outputs. No blocking — if either finds zero issues, that is a valid result.

Escalation: If Critic flags any concern as "fundamentally wrong plan," STOP and escalate to the human before proceeding. Do not enter the implementation phase.

Phase 2: Architecture (sequential)

Architect runs alone. Reads the plan, Explorer's research brief, and Critic's concerns list.

Agent	Input	Output
Architect	Plan + Explorer brief + Critic concerns	Architecture doc, concern resolutions, module assignments

Gate: Architect must resolve or accept every Critic concern before Builders start.

Phase 3: Build (parallel per module)

Builders work on independent modules in parallel. Each Builder reads the Architect's architecture doc and their assigned module spec.

Agent	Input	Output
Builder (x N)	Architecture doc + module assignment	Implementation code + implementation notes

Gate: Each module must be complete (all files written, all error paths handled) before passing to Review + Test.

Phase 4: Review + Test (parallel per module)

Reviewer and Tester work concurrently on each completed module.

Agent	Input	Output
Reviewer	Builder's code + architecture doc + Critic concerns	Review report (approve/reject)
Tester	Builder's code + architecture doc + Critic concerns	Test suite + coverage report

Gate: Both Reviewer and Tester must approve before a module passes to Integration. If Reviewer rejects, Builder fixes and resubmits. If Tester finds bugs, Builder fixes and Tester re-runs.

Phase 5: Integration (sequential)

Integrator merges approved modules one at a time.

Agent	Input	Output
Integrator	Approved modules + test suites	Merged branch, integration test results, ship report

Gate: Full test suite must pass on the merged branch. Ship report must be produced before marking complete.

On-Demand Consultation

Advisory agents remain available throughout all phases:

Caller	Callee	When
Builder	Explorer	"Is library X still the right choice?" / "What's the latest version of Y?"
Builder	Architect	"The interface says Z but I think it needs W — should I change it?"
Reviewer	Critic	"Does this code address concern #3?"
Tester	Critic	"What edge cases should I test for module X?"
Integrator	Builder	"Your module conflicts with module B at function F — which is correct?"

Escalation to Human

Any agent may escalate when:

• Critic flags "fundamentally wrong plan" (not just flawed)
• Explorer finds a core dependency is deprecated with no viable alternative
• Reviewer and Builder cannot agree after one review-fix cycle
• Integrator cannot merge without new architecture decisions

Escalation format: one paragraph — the problem, the options considered, and the decision needed. No preamble.

Attribution

These agent definitions synthesize principles from 12 foundational sources. See _principles.md for the shared rules and the spec at docs/superpowers/specs/2026-04-15-agentic-guidelines-design.md for the full canon with citations.