dev-squad-marketplace

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