| name | team |
| description | Full multi-agent team review using parallel subagents. Spawns Architect, SecOps, Tester, DevOps, and Verifier concurrently, then consolidates into a prioritized action plan. |
| argument-hint | [description of what to review] |
| user_invocable | true |
| tools | Read, Glob, Grep, Bash, WebFetch, WebSearch |
| model | inherit |
/team — Full Team Review
Run a multi-agent review of the current change or feature using parallel subagents. Each agent runs in its own context window for deep, focused analysis.
Target
$ARGUMENTS
Process
Step 1 — Parallel Agent Spawn
Launch all five review agents concurrently using the Task tool. Each agent gets the review target as context and produces a focused assessment.
Use a single message with multiple Task tool calls:
- Architect (
subagent_type: architect, model: "opus") — Think deeply about the architectural implications. Evaluate system design, module boundaries, API contracts, and dependency decisions for: $ARGUMENTS
- SecOps (
subagent_type: secops, model: "opus") — Think deeply about the security implications. Enumerate all attack vectors. Security review: input validation, crypto correctness, dependency vulnerabilities, secret detection for: $ARGUMENTS
- Tester (
subagent_type: tester) — Identify test gaps, suggest edge cases, evaluate coverage for: $ARGUMENTS
- DevOps (
subagent_type: devops) — Assess build/deploy impact, CI pipeline changes, configuration updates for: $ARGUMENTS
- Verifier (
subagent_type: verifier) — Run tests, lint, and build checks. Report current pass/fail state for: $ARGUMENTS
Note: Architect and SecOps use extended thinking (model: "opus") for deeper analysis. Tester, DevOps, and Verifier use standard model for speed.
Handling subagent failures: If any agent returns INCOMPLETE or ESCALATING, note it in the consolidation. Don't re-spawn — report the partial result with the agent's handoff notes.
All five agents run in parallel. Wait for all to complete before proceeding.
Step 2 — Consolidation
After all agents return, synthesize their findings into a single prioritized report. Cross-reference findings — if SecOps flags a vulnerability and Tester is missing a test for it, link them. If Architect suggests a design change and DevOps sees a build impact, connect those.
Step 3 — Simplification Check
If the review reveals implementation complexity, note where Simplifier could reduce it. This is advisory — don't spawn Simplifier unless the user asks.
Output
# Team Review: [Subject]
## Architect
[Design assessment — API contracts, module boundaries, dependency impact]
## SecOps
[Security findings — risk level: LOW/MEDIUM/HIGH/CRITICAL]
## Tester
[Coverage assessment — gaps found, edge cases to add, recommended tests]
## DevOps
[Build/deploy impact — CI changes, config updates, infrastructure needs]
## Verifier
[Current state — tests passing/failing, lint status, build status]
## Simplification Opportunities
[Where complexity could be reduced, or "None identified"]
## Action Plan
Priority 1 (Blocking):
- [ ] [item — agent source]
Priority 2 (Should fix):
- [ ] [item — agent source]
Priority 3 (Nice to have):
- [ ] [item — agent source]
When to Use
- Before merging a significant change
- Reviewing a new feature's design and implementation
- Assessing project posture or technical debt
- After a dependency update or security advisory
- Any time the user invokes
/team with a review target
