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

Install

# 1. Add the Dev Squad marketplace
claude plugin marketplace add LeoHeo/dev-squad

# 2. Install the plugin
claude plugin install dev-squad

Run

# Full feature development with Dev Squad
/new-feature

# Or use individual skills independently
/start-work      # Branch setup + project detection
/qa              # Intent-based UI QA testing
/test            # Run tests (auto-detects framework)
/build-all       # Build all projects

First Run

1. /new-feature detects your project structure automatically
2. Enter your feature name and requirements
3. Watch 6 agents collaborate to build, review, and test your feature
4. Get a complete summary with commit-ready code

---

Supported Stacks

Auto-detected from your project files. No configuration needed.

Stack	Detection	Build	Test
Spring Boot (Gradle)	build.gradle + Spring deps	./gradlew clean build	./gradlew test
Spring Boot (Maven)	pom.xml + Spring deps	./mvnw clean package	./mvnw test
Nuxt 3	nuxt.config.ts	npm run build	npm run test:unit
Next.js	next.config.*	npm run build	npm run test:unit
Vite	vite.config.*	npm run build	npm run test:unit
Go	go.mod	go build ./...	go test ./...
Rust	Cargo.toml	cargo build --release	cargo test
Node.js	package.json	npm run build	npm run test:unit

Monorepo? Dev Squad scans all subdirectories and handles each one by its type.

---

Skills Reference

/new-feature — Full Feature Development

The main skill. Runs all 7 phases with Dev Squad collaboration.

/start-work — Environment Prep

Standalone branch setup:

• Detect project directories and types
• Handle uncommitted changes (stash / ignore / abort)
• Select base branch + create feature branch
• Generate project-config.json

/qa — Intent-Based QA

Standalone QA testing:

• Auto-start dev servers if not running
• Run all scenarios or specific pages
• Auto-healing for failed UI steps (3-level)
• UX/UI improvement analysis

/test — Framework-Aware Testing

Runs tests using the correct command for each project type.

/build-all — Multi-Project Build

Builds all detected projects in sequence using type-appropriate commands.

---

Customization

Override Agents

Copy any agent from the plugin to your project's .claude/agents/ directory and modify it. Project-level agents take priority over plugin agents.

# Example: customize the security review for your project
cp ~/.claude/plugins/cache/.../agents/security-senior.md .claude/agents/security-senior.md
# Edit to add project-specific security rules

Project Config

The plugin generates .claude/project-config.json on first run:

{
  "directories": [
    { "name": "backend", "path": "backend", "type": "spring-boot" },
    { "name": "frontend", "path": "frontend", "type": "nuxt" }
  ],
  "baseBranch": "master",
  "branchPrefix": "feature/"
}

Edit this file to customize branch strategy, exclude directories, or override detected types.

---

Why It Works

Advantage	Single Agent	Agent Teams
Defect detection	Self-review bias — misses own mistakes	Independent reviewers catch what the author can't
Security coverage	Security is an afterthought	Dedicated Security Sr. audits every change
Spec compliance	No one verifies requirements are met	CTO Lead validates match rate before shipping
API integration	Frontend guesses backend shape	Real-time contract negotiation via SendMessage
Rework	Bugs found late → expensive fixes	Parallel verification catches issues early

---

Language

• README: English
• Skills & Agents: Korean (한국어)
• English version of skills/agents: planned for future release

한국어 README

---

FAQ

Q: Why not just use one agent? A single agent reviewing its own code is like a chef tasting their own food — they already know what it should taste like. Dev Squad's Security Sr. and QA Sr. review code they didn't write, catching issues the author is blind to.

Q: Does this actually speed things up? Frontend and Backend work in parallel, not sequentially. Verification (code review + security + QA + requirements) also runs in parallel. The wall-clock time drops significantly.

Q: What if agents disagree? CTO Lead is the final arbiter. When Frontend Sr. and Backend Sr. negotiate API contracts via SendMessage, CTO Lead validates the result against requirements. Disagreements are resolved through the same message protocol.

Q: Can I customize agent behavior? Yes. Copy any agent from the plugin to .claude/agents/ and modify it. Project-level agents override plugin agents. See Customization.

Q: Do I need bkit installed? No. Dev Squad is fully independent. But bkit + Dev Squad together give you PDCA lifecycle management on top of multi-agent collaboration.

---

Thanks To

If I have seen further, it is by standing on the shoulders of giants.

bkit (Vibecoding Kit) by POPUP STUDIO PTE. LTD.

Dev Squad wouldn't exist without bkit's pioneering PDCA methodology. Here's what bkit taught us:

• "Plan first, code later" — AI agents need structured phases, not ad-hoc prompting
• The power of quality gates — Verification at each stage is what guarantees output quality
• Document-driven development — Plan docs and QA scenarios should exist before code does

We took these lessons and added one more question: What if each phase had its own specialist?

bkit is licensed under Apache 2.0. Dev Squad works independently, but bkit + Dev Squad together connect PDCA lifecycle management with multi-agent team collaboration. Highly recommended.

License

MIT — see LICENSE and NOTICE for attribution details.

---

Stop asking one agent to do six jobs.
Give each job to the right specialist.