Dev Squad
Ship production-ready features with a team of 6 AI agents — not a single overwhelmed one.
One command. Six specialists. Production-ready code.
/new-feature
🔍 Detecting project... Spring Boot + Nuxt 3 (monorepo)
👔 CTO Lead → Breaking down requirements into 4 tasks
🎨 Frontend Sr. → "I need the API contract for /api/users"
⚙️ Backend Sr. → "Here's the spec: GET /api/users → UserListResponse"
🎨 Frontend Sr. → "Got it, building the table component now"
🛡️ Security Sr. → "Found: missing @PreAuthorize on PUT endpoint"
⚙️ Backend Sr. → "Fixed, added hasAuthority('PERM_USER_EDIT')"
🧪 QA Sr. → "All 12 scenarios passed, 0 failures"
👔 CTO Lead → "Requirements match rate: 96%. Ship it."
✅ 4 commits created on feature/user-management
This is what happens when you stop asking one agent to do six jobs.
Real Session Capture
This is an actual Dev Squad session — CTO Lead orchestrating 6 agents working in parallel via tmux:
The Problem
When a single AI agent builds a feature end-to-end, it:
- Loses context switching between frontend, backend, and infrastructure
- Skips security review because it wrote the code itself (self-review bias)
- Misses edge cases in QA because it already "knows" what the code does
- Drifts from spec with no one to catch deviations in real time
Anthropic proved this at scale: 16 parallel agents built a 100,000-line C compiler that compiles Linux 6.9 — in just 2 weeks, across ~2,000 sessions. Specialized agents for dedup, optimization, and code generation each did what a single agent couldn't.
The Solution
Dev Squad assigns 6 specialized agents — each with deep expertise and a clear role — that collaborate in real time via SendMessage, just like a real development team.
| Agent | Role | What It Does |
|---|
| CTO Lead | Orchestrator | Breaks down requirements, assigns tasks, validates results. Never writes code. |
| Frontend Sr. | UI Engineer | Components, pages, API integration. Follows existing patterns. |
| Backend Sr. | API Engineer | Endpoints, services, data models, migrations. TDD approach. |
| UI/UX Sr. | Designer | Screen specs, component trees, interaction flows. Design only. |
| Security Sr. | Security Auditor | OWASP Top 10, auth/RBAC, input validation. Reports — never fixes. |
| QA Sr. | Quality Engineer | Test strategy, unit/E2E/intent-based UI tests. Breaks things on purpose. |
Why Separation Matters
| Principle | Single Agent | Agent Teams |
|---|
| Self-review bias | Same agent reviews its own code | Security Sr. + QA Sr. review independently |
| Context window | One context holds everything — overflow risk | Each agent has focused, relevant context |
| Spec compliance | No one checks if code matches requirements | CTO Lead validates requirement match rate |
| API contract | Frontend guesses backend shape | Frontend ↔ Backend negotiate via SendMessage |
How It Works
Phase 1 — Project Detection + Branch
Auto-detects your stack (Spring Boot, Nuxt, Next.js, Vite, Go, Rust, etc.) and creates a feature branch.
Phase 2 — Team Formation + Planning
Spawns 6 agents as a real Claude Code Team (TeamCreate). Agents communicate via SendMessage to produce a collaborative plan.
Phase 3 — Parallel Implementation
Frontend and Backend seniors work simultaneously. They negotiate API contracts in real time — no spec drift, no integration surprises.
Phase 4 — Parallel Verification
4 checks run at once:
- Code review (Frontend + Backend)
- Security audit (OWASP Top 10)
- QA testing (Unit + E2E + Intent-based)
- Requirement match rate (CTO Lead)
Phase 5-6 — Smart Commit + Push
Conventional Commits with logical splits. Each commit = one logical change. Then push or merge.
Phase 7 — Cleanup
Kill dev servers, terminate workers, disband team. Clean exit.
Quick Start
