Who this is for: Developers using Claude Code for real projects who want a clear upgrade path from basic usage to full multi-agent orchestration. Works whether you're a solo dev or on a team.
What you'll need:
- Claude Code installed and working — see Getting Started if you need setup help
- 25 minutes for manual setup — or under a minute with a pre-built template
- You can follow along with any folder — no existing project required
Most developers start with Claude Code the same way: open the CLI, type a request, get a response. It works. But as projects grow, that single conversation becomes a bottleneck. You're asking one assistant to plan, code, review, test, and remember context from three conversations ago.
This post walks through upgrading your workflow in stages — from solo to a fully coordinated agent team.
Quick comparison
| Solo | Agent Team | |
|---|---|---|
| Planning | Ad-hoc, in the same conversation | PM breaks into structured tasks |
| Implementation | Generic instructions every time | Developer follows focused rules |
| Review | Self-review (easy to miss things) | Separate reviewer with a checklist |
| Process | Manual — you manage every step | PM delegates and tracks automatically |
| Quality | Inconsistent | Consistent — same checks every time |
The rest of this post shows how to get from the left column to the right, one stage at a time.
Stage 1: Solo — one conversation does everything
This is where everyone starts:
You: "Add user authentication with JWT"
Claude: Plans it, codes it, maybe misses edge cases
You: "Now review what you just wrote"
Claude: Reviews its own code (not great at catching its own mistakes)What works: Fast for small tasks. No setup needed.
What breaks: Context gets long. Self-review is weak. Instructions compete. Claude tries to plan, code, and review in the same breath.
Stage 2: Agents — separate personas
The first upgrade is splitting roles into agents. Create two files:
.claude/agents/developer.md:
---
name: developer
description: Implements features with clean TypeScript code.
model: sonnet
tools:
- Read
- Edit
- Write
- Bash
- Grep
- Glob
permissionMode: acceptEdits
---
# Developer
You implement features for this project.
## Rules
- Follow existing code patterns and naming conventions
- Run the linter after every change
- Write self-documenting code — no unnecessary comments.claude/agents/reviewer.md:
---
name: reviewer
description: Reviews code changes for bugs, security, and quality.
model: sonnet
tools:
- Read
- Grep
- Glob
permissionMode: plan
---
# Code Reviewer
You review code changes for quality and security.
## Checklist
1. Check for OWASP Top 10 vulnerabilities
2. Verify error handling on external calls
3. Flag functions longer than 50 lines
4. Check naming consistency
## Rules
- Never modify code — only suggest changes
- Use severity tags: Blocking, Warning, NitWhat changes: Claude now uses different personas for different tasks. The developer doesn't try to review. The reviewer doesn't try to fix code. Each stays focused.
Stage 3: Skills — repeatable workflows
Agents define who. Skills define what to do. Add slash commands for your most common workflows.
.claude/skills/implement/SKILL.md:
---
name: implement
description: Implement a feature
context: fork
agent: developer
---
# Implement
Build the following: $ARGUMENTS
## Steps
1. Read existing code in the affected area
2. Implement the change following project conventions
3. Run `npm run lint` and fix any issues
4. Run `npm test` if tests exist
5. Summarize what was changed.claude/skills/review/SKILL.md:
---
name: review
description: Review recent code changes
user-invocable: true
context: fork
agent: reviewer
---
# Review
Review the following: $ARGUMENTS
## Steps
1. Run `git diff` to see recent changes
2. Check each changed file against the review checklist
3. Output findings with severity tagsNow your workflow is:
/implement "Add JWT authentication"
→ Developer agent implements it
/review
→ Reviewer agent checks the changesWhat changes: Consistent process every time. No more typing out instructions for each task.
Stage 4: Orchestration — agents delegate to agents
The final upgrade is adding a product manager who coordinates everything.
.claude/agents/product-manager.md:
---
name: product-manager
description: >-
Plans features and delegates to developer and reviewer agents.
model: opus
tools:
- Read
- Grep
- Glob
- Task
permissionMode: plan
---
# Product Manager
You plan features and coordinate the development team.
## Process
1. Break the request into implementation tasks
2. Delegate each task to the developer agent
3. After implementation, delegate review to the reviewer agent
4. If the reviewer finds issues, delegate fixes back to the developer
5. Report the final outcome
## Rules
- Never implement code yourself
- Keep tasks small (1-2 files per task)
- Cap fix-review loops at 2 iterationsNow a single request triggers the whole pipeline. Behind the scenes, Claude Code's main session reads each agent's description and delegates to the right specialist at each step — the PM plans, the developer implements, and the reviewer checks:
You: "Add JWT authentication"
PM plans the work:
1. Create auth middleware
2. Add login/register endpoints
3. Add JWT token utilities
Developer: "Implement auth middleware"
Developer: Creates middleware, runs linter ✓
Developer: "Implement login/register endpoints"
Developer: Creates endpoints ✓
Reviewer: "Review all auth changes"
Reviewer: "Warning: token expiry not handled in refresh flow"
Developer: "Fix token refresh handling"
Developer: Adds refresh logic ✓
Done: "Feature complete. 4 files added, all checks passing."How delegation actually works: Subagents can't spawn other subagents. The main Claude Code session orchestrates the chain — it sends planning tasks to the PM, implementation to the developer, and reviews to the reviewer. From your perspective it feels automatic, but the main session is the coordinator.
The before/after
| Solo | Agent Team | |
|---|---|---|
| Planning | Ad-hoc, in the same conversation | PM breaks into structured tasks |
| Implementation | Generic instructions every time | Developer follows focused rules |
| Review | Self-review (easy to miss things) | Separate reviewer with a checklist |
| Process | Manual — you manage every step | PM delegates and tracks automatically |
| Quality | Inconsistent | Consistent — same checks every time |
How long does setup take?
- Stage 2 (agents): 10 minutes — create 2 markdown files
- Stage 3 (skills): 10 more minutes — create 2-3 SKILL.md files
- Stage 4 (orchestration): 5 more minutes — add a PM agent with Task tool
Total: under 30 minutes to go from solo to a coordinated team.
Or under a minute if you use a pre-built template.
Choosing the right level
Not every project needs full orchestration:
- Side project or script: Stage 1 (solo) is fine
- Active codebase you maintain: Stage 2-3 (agents + skills)
- Team project or production app: Stage 4 (full orchestration)
Start at Stage 2. Add skills when you notice repetition. Add orchestration when you need multi-step workflows that span multiple concerns.
Get started
- Free template: Startup Dev Team — 4 agents, 5 skills, ready for Stage 2-4
- Full power: Enterprise Dev Team — 8 agents, 13 skills, with advanced review and UX checking
- Learn more: What are agents? and Create your first skill