// tool · 04 / 05
Dev-team-agents
A dev team's rigor from one Claude Code session. Specialist subagents, enforced handoffs, and review the author didn't write.
// what is it
A multi-agent dev team for Claude Code, with enforced handoffs.
Dev-team-agents turns a single Claude Code session into a coordinated team. The main thread becomes an Orchestrator that classifies each task, picks a pipeline, and dispatches specialists — analyst, architect, developer (Sonnet or Opus tier), QA, reviewer, debugger, DevOps, git, doc-keeper. Each agent has a narrow charter, a defined output file, and a model tier that fits its job.
Agents communicate through a file bus under .claude-team/, not through inline chat — their contexts stay clean and the whole pipeline is auditable. A plan-review stage catches design defects before any code is written. Open source, MIT-licensed.
// the problem
The context that wrote the code can't review it.
In a single Claude Code session, one context drafts the requirements, writes the code, reviews its own work, and commits. That's fast — and on trivial changes it's fine. On real features, refactors, and bugs it breaks down: review quality collapses when the reviewer is the same context that just wrote the code, and design defects slip straight through to the diff.
Dev-team-agents separates those concerns into specialist subagents and enforces the handoffs with hooks. Each agent has a narrow charter and a defined output. A plan-review stage runs before any code is written. The review is done by a context that didn't write the code — and a commit is blocked until it's approved.
The result is work you can put through code review — caught before the diff, not after the merge.
// how it works
One thread orchestrates. Specialists do the work.
- // 01
Describe the task in plain English.
Give the session a task the way you'd tell a teammate — "add a
/healthendpoint", "fix the auth redirect bug". The Orchestrator classifies it (feature / bug / refactor / setup / research) and picks the lightest pipeline that fits. - // 02
Plan, then review the plan.
The Architect writes the implementation plan; the Analyst validates it against requirements; a reviewer signs off before a line of code is written. Design defects get caught at the plan stage, where they're cheap.
- // 03
Build with tests.
The Developer reads the approved plan and implements it; QA writes failing tests first for bugs, characterization tests for refactors. Each agent writes to its own file under
.claude-team/, so contexts stay clean. - // 04
Review by a different context.
A reviewer that didn't write the code critiques the diff; disagreements trigger a rebuttal the Architect arbitrates. A commit is blocked at the hook level until review shows approved. OpenAI Codex can serve as an optional second reviewer, with automatic fallback.
- // 05
Commit, then remember.
The Git agent makes atomic conventional commits; the Doc-keeper updates project memory and docs. Restart later and the pipeline still knows the decisions, patterns, and gotchas from before.
// who it's for
Senior devs, founders, and teams shipping real work with Claude Code.
Dev-team-agents is for builders already shipping non-trivial work with Claude Code — real features, refactors, production bugs — who've felt the quality drop when one session does everything. If your problem is rigor at scale, not getting started, this is the layer that adds it.
Best fit: features, bugs, and refactors big enough to deserve a plan and a real review. Worst fit: one-line changes and throwaway scripts — the Orchestrator runs those down the lightest path anyway, so you won't feel the difference.
// compatibility
Compatibility
// get started
Install the plugin, give it a task.
Open source, MIT-licensed. Install via Claude Code's plugin marketplace, or clone the repo and link it locally — then point the main thread at the Orchestrator and give it a task in plain English.
Get notified when Dev-team-agents ships a major update.
// subscribed
Check your inbox for the confirmation link.