There is a well-worn startup fantasy: hire slowly, stay lean, do more with less. The reality is that "lean" still meant five people, a payroll, and a Slack that never sleeps.
That is changing. Not because of some vague promise about AI. Because of something very specific: the ability to build a team of specialized agents that each start with a clean context, run a defined job, and report back — in parallel, for fractions of a cent per task.
I am not talking about chatbots. I am talking about Claude Code's agent team feature. Let me show you what it actually looks like.
The problem with doing everything yourself
When you are building alone, every task competes for the same resource: your attention. You are in the middle of debugging an authentication flow and you also need to write a README, audit the latest diff for security holes, and figure out where the session logic lives across twelve files.
Sequential execution. One thing at a time. You are the bottleneck.
The agent team model flips this. Each agent gets its own clean context window, its own task, and runs independently. You describe the work, delegate it, and come back to results instead of doing everything inline.
What an agent actually is
In Claude Code, an agent is a subprocess. It:
- Starts cold with an empty context window
- Receives a task via a prompt you write
- Has access to a specific set of tools (read files, run commands, search the web, write code)
- Returns one summary back to the parent session
Agents can run in the foreground (parent waits for the result) or in the background (you keep working while the agent runs). A panel called FleetView shows all agents active in the current session.
The key detail is this: when an agent searches through forty files to answer a question, all that noise — the dead ends, the partial reads, the exploration — stays in the agent's context, not yours. You receive only the signal.
The five-person company, without the five people
Here is the team I use. These are real agent definition files you can drop into ~/.claude/agents/ and use today.
The Planner (Opus, read-only)
Before anything substantial gets built, the Planner reads the relevant code and produces: the current state, a step-by-step implementation plan, and the trade-offs. It never writes code. It just thinks.
---
name: planner
description: >
Use for designing implementation strategies, evaluating architectural
trade-offs, and producing step-by-step plans before coding starts.
Invoke before builder on any non-trivial feature.
model: claude-opus-4-8
tools: [Read, Grep, Glob]
---
You are a software architect. When given a task, read the relevant code first,
then produce: (1) a concise summary of the current state, (2) a step-by-step
implementation plan, (3) any risks or trade-offs the implementer should know.
Do not write code — produce plans only.
This is the most expensive agent in the team and the most rarely used. One focused Opus planning session before a large feature is worth more than ten rushed implementation attempts.
The Builder (Sonnet, full tool access)
The Builder implements what the Planner designs. Reads before writing, makes minimal changes, no scope creep.
---
name: builder
description: >
Use for writing, refactoring, or extending code.
Delegate well-scoped implementation tasks — a feature, a fix, a refactor.
Not for vague exploration or architecture decisions.
model: claude-sonnet-4-6
tools: [Read, Write, Edit, Bash, Glob, Grep]
---
You are a surgical code writer. Read existing code and conventions before making
any change. Make the smallest change that solves the problem. No scope creep.
No unrequested refactors. Never hardcode secrets — flag any you find.
The Reviewer (Haiku, read-only)
Runs after the Builder finishes. Audits for correctness, security issues, and consistency. Read-only — it does not write code, it finds problems. Running it on Haiku keeps the cost negligible.
---
name: reviewer
description: >
Use to audit code changes, diffs, or commits for correctness, security, and
consistency. Read-only — does not write code. Run after builder finishes,
or on demand for any diff.
model: claude-haiku-4-5-20251001
tools: [Read, Grep, Glob]
---
You are a read-only code auditor. Review for correctness bugs, security issues
(injection, hardcoded secrets, unsafe deserialization), and consistency with
surrounding code. Report findings as a concise bulleted list. Flag anything
security-critical as REQUIRES SENIOR REVIEW.
The Scout (Haiku, retrieval only)
Pure data retrieval. No analysis. Lists files, reads configs, extracts function signatures, checks whether a symbol exists. The cheapest agent in the team, and the most frequently used.
---
name: scout
description: >
Use for cheap, high-volume data retrieval — reading files, listing paths,
extracting function signatures, checking if a symbol exists. No analysis,
just clean structured data. Feed its output to smarter agents.
model: claude-haiku-4-5-20251001
tools: [Read, Grep, Glob, WebSearch, WebFetch]
---
Your only job is to retrieve and return data exactly as requested. No analysis,
no opinions, no suggestions. Return results in the format the caller specifies.
Never add explanations.
The Writer (Sonnet, content-focused)
Documentation, tutorials, README files, blog posts. Reads the codebase and the existing docs to match tone, then produces finished prose.
---
name: writer
description: >
Use for writing tutorials, documentation, README files, and technical
blog posts. Turns feature descriptions or outlines into finished,
publish-ready prose. Does not write code.
model: claude-sonnet-4-6
tools: [Read, Grep, Glob, WebSearch, WebFetch]
---
You write clear, practical technical content for developers. No filler,
no preamble, no marketing language. Use short sentences and real examples.
Match the tone and style of existing documentation in the project.
How a real workday looks
Here is an actual request I sent this week to kick off a new feature:
Before I implement the new export function, run these in parallel:
1. Scout agent — list every file under src/export/ and every file that
imports anything from it. Return paths only.
2. Scout agent — find all open GitHub issues mentioning "export" or "download".
Return a one-paragraph summary.
When both are done, hand the results to the Planner and ask it to design
the implementation.
Two Haiku agents run simultaneously. I keep working. Two minutes later, the Planner has the context it needs and produces a plan. The Builder implements it. The Reviewer audits the diff. Total wall-clock time for something that would have taken me two hours of context-switching: about fifteen minutes of active attention.
The cost math
Running five Haiku Scout agents to scan a large codebase costs roughly the same as asking one Sonnet agent to do the same thing sequentially — and finishes in parallel. A full Planner-Builder-Reviewer cycle for a medium-sized feature runs around $0.05 to $0.20 depending on codebase size.
The model selection rule is simple:
- Data retrieval, file listing, pattern matching → Haiku
- Code writing, moderate reasoning → Sonnet
- Architecture decisions, complex debugging, security review → Opus
You only pay Opus rates when the task genuinely requires Opus-level reasoning. Everything else runs cheaper.
Document the team in CLAUDE.md
Drop this in the root of your project so every session knows who is available and when to use them:
## The crew
| Agent | Model | Use for |
|---|---|---|
| `planner` | opus | Architecture decisions before any large feature |
| `builder` | sonnet | Writing / refactoring / extending code |
| `reviewer` | haiku | Auditing diffs — run after builder |
| `scout` | haiku | File retrieval and data extraction |
| `writer` | sonnet | Documentation, tutorials, README files |
## Delegation rules
- Delegate chunky, well-scoped jobs. Keep coordination in the main thread.
- builder implements → reviewer audits. Skip review for trivial edits.
- Never invoke planner for tasks that are already well-defined — go straight to builder.
- scout feeds data to other agents. Never ask it to reason or analyze.
Claude Code reads this at session start. The agents become part of the project's institutional knowledge, available to anyone who opens the project.
The thing nobody says out loud
A company is, at its core, a set of roles that produce value. A planner that thinks ahead. A builder that executes. A reviewer that catches mistakes. A researcher that gathers data. A writer that communicates.
Those roles do not require people. They require judgment, tools, and a system that connects them.
I am not saying agents replace human collaboration for everything — complex judgment calls, client relationships, decisions with high stakes and ambiguity still benefit from people. But for the execution layer — the reading, the writing, the building, the auditing — the agent team handles it. The humans monitor the progress, note the flaws, and improve the agents accordingly.
The first wave of solo founders who treat AI agents as their actual operating structure, rather than an occasional tool, are going to look very strange to the next generation. The same way a 2005 startup with a physical server room looks strange to us now.
The infrastructure shifted. The question is whether you are using it.
The technical deep-dive on setting up Claude Code's agent team — including agent file format, model selection, FleetView, and cost optimization patterns — is in the full tutorial on SysEmperor. The AI Skills library has downloadable Claude skill prompts for code review, debugging, documentation, and more.
