How to Actually Build Your First Team of AI Agents Using Claude Opus 5.5 (Full Course)
文章目录
Most people using AI right now are doing it wrong.
They open one chat. They dump in a giant prompt. They ask one model to research, plan, write, code, review and fix.
All in one window.
Then they wonder why the output is mid.
Here's the thing nobody tells you.
One agent doing everything is not an AI team. It's an overworked intern with amnesia.
The people getting INSANE leverage out of AI right now aren't writing better prompts. They're building teams.
A researcher that only researches. A builder that only builds. A critic that only tears things apart. And a lead that hands out the work and stitches it together.
Each one focused. Each one with its own instructions. Each one with its own clean context.
That's the shift. And with Claude Opus 5.5 running the show, it's never been easier to set up.
This guide walks you through building your first AI agent team from zero. No framework. No PhD. No 40 tabs of documentation.
By the end you'll have a working team of four agents that can take a single request and turn it into finished, reviewed work while you do something else.
Let's build.
Why one agent hits a wall
Before we build the team, you need to understand WHY a single agent breaks down. Because once you see it, you'll design around it.
Problem 1: Context gets polluted.
Every time you ask one agent to do a new job, it carries everything from the last job with it. Research notes. Failed code attempts. Half finished drafts. Your three corrections from an hour ago.
By task five, the model is reading a novel of irrelevant history before it does anything. Quality drops. Mistakes creep in. It starts "remembering" things that were true four steps ago and aren't anymore.
Problem 2: One brain can't check its own work.
Ask a model to write something and then review it in the same thread, and it will mostly agree with itself. It already decided that was the right answer. It's grading its own homework.
A SEPARATE agent with a separate brief and no memory of writing it will catch things the author never will.
Problem 3: Jack of all trades, master of none.
A prompt that says "you are a world class researcher, copywriter, engineer and editor" isn't four experts. It's one generalist pretending.
A focused agent with ONE job, ONE set of rules and ONE definition of done performs dramatically better.
Problem 4: Everything happens in a line.
One agent works step by step. Research, then plan, then build, then review. A team can split the work and run pieces in parallel.
That's the whole case for a team.
Clean context. Independent review. Specialists over generalists. Parallel work.
What an AI agent team actually is
Strip away the hype and an agent team is simple.
A lead agent that understands the goal, breaks it into tasks and assigns them.
Specialist agents that each do one kind of work, with their own instructions and their own tools.
A shared workspace where they hand work to each other.
Rules everyone follows.
That's it. That's the architecture.
The lead is where Opus 5.5 shines. Planning, judgment, knowing what "good" looks like, deciding what to do when something goes wrong. That's the hardest job on the team, so it gets the strongest model.
The specialists can be Opus too, or lighter models for the repetitive work. More on that in the cost section.
The tool we're using: Claude Code subagents
You can build agent teams a lot of ways. Python frameworks. Visual builders. Custom API code.
For your FIRST team, I'm going to tell you to skip all of that.
Use Claude Code subagents.
Here's why:
-
Each subagent is just a markdown file. No code required.
-
Each one runs in its own context window, so the lead stays clean.
-
Each one gets its own system prompt and its own tool permissions.
-
The lead (your main Claude Code session) can call them automatically or when you ask.
-
Your whole team lives in a folder you can version, copy and reuse.
You describe the team in plain English. Claude Code runs it.
And when you outgrow it, everything you learned here transfers to any framework.
The team we're building
We're going to build a Launch Team. Four agents that take one idea and turn it into a researched, written, reviewed launch package.
I picked this because almost everyone reading this has something to launch. A product. A newsletter. A service. A side project. Swap the use case later. The structure stays the same.
Here's the roster:
1. The Lead (Opus 5.5, your main session)Understands the goal. Writes the brief. Assigns work. Makes the final call.
2. Scout (the researcher)Finds facts, competitors, pricing, audience pain points. Cites every source. Never writes copy.
3. Maker (the builder)Turns the brief and research into the actual deliverable. Landing page copy, emails, posts, whatever the job is.
4. Critic (the reviewer)Reads Maker's work cold. Checks it against the brief and the research. Flags weak claims, fluff and anything unverified. Never rewrites. Only judges.
Notice the pattern.
Scout never writes. Maker never researches. Critic never fixes.
Hard boundaries are what make a team work. The moment one agent starts doing another's job, you're back to one overloaded brain.
Step 1: Pick ONE workflow to automate
The number one mistake people make with agent teams is starting too big.
"I want an AI company that runs my whole business."
No. You want ONE workflow that you do repeatedly, that has clear steps, and that you already know how to do well.
Good first workflows:
-
Research a topic and turn it into a newsletter
-
Take a product idea and produce a landing page plus launch posts
-
Review a pull request for bugs, security issues and style
-
Turn a long video transcript into a thread, a blog post and an email
-
Analyze competitor pricing and summarize where you can win
Bad first workflows:
-
"Run my marketing"
-
"Build my startup"
-
Anything you couldn't explain to a human assistant in five minutes
Write your workflow down as numbered steps before you touch any tool. If you can't write the steps, the agents can't follow them.
For our Launch Team, the workflow is:
- Take a product idea from me
- Research the market, competitors and audience pain points
- Write a launch package: landing page copy, 3 launch posts, 1 email
- Review everything against the research and the brief
- Fix what the review flags
- Hand me the final package with sources
Six steps. Clear inputs. Clear outputs. Perfect first team.
Step 2: Set up the project folder
Install Claude Code if you haven't, then create a folder for your team. Open your terminal and run:
mkdir launch-team cd launch-team mkdir workspace mkdir .claude mkdir .claude/agents mkdir .claude/commands
Here's what each folder does:
launch-team/ CLAUDE.md team rules every agent follows workspace/ where agents hand work to each other .claude/agents/ one file per specialist agent .claude/commands/ shortcuts that kick off the whole workflow
That workspace/ folder is more important than it looks. It's how your agents talk to each other. Scout writes research to a file. Maker reads that file. Critic reads both. No copy pasting. No lost context. Everything on disk where you can inspect it.
Now launch Claude Code inside the folder:
claude
Make sure you're on Opus 5.5 for the lead session. Use the /model command to check and switch.
Step 3: Write the team rules in CLAUDE.md
Claude Code automatically reads CLAUDE.md at the start of every session. Think of it as the team handbook. The lead reads it, and you'll point every specialist at it too.
Create CLAUDE.md in the root of your project:
Launch Team Handbook
The team
You are the Lead. You plan, delegate and make final calls. You have three specialists: * scout: research only. Never writes copy. * maker: writes deliverables only. Never does research. * critic: reviews only. Never rewrites, only flags.
How work flows
- Lead writes a brief to workspace/brief.md
- scout reads the brief and writes workspace/research.md
- maker reads brief + research and writes workspace/draft.md
- critic reads all three and writes workspace/review.md
- maker fixes everything critic flags in workspace/final.md
- Lead checks final.md against the brief and delivers it
Rules for everyone
- Every factual claim needs a source in research.md * If a fact is not in research.md, maker cannot use it * No made up numbers, testimonials or quotes. Ever. * Write plainly. No hype words like "revolutionary" or "game changing" * If you are unsure, say so in your output instead of guessing * Stay in your lane. Do your job, then stop.
Definition of done
The final package matches the brief, every claim is sourced, critic has no unresolved HIGH severity issues, and the Lead has read it end to end.
Read that rules section again. "If a fact is not in research.md, maker cannot use it." That one line kills most AI hallucination in your output. The writer can only use what the researcher actually found.
Step 4: Build Scout, the researcher
Each specialist is a markdown file in .claude/agents/ with a small header on top and the system prompt below it.
The header holds:
-
name: how the lead refers to the agent
-
description: WHEN to use it. The lead reads this to decide who gets which task, so write it carefully.
-
tools: what it's allowed to touch
-
model: which model runs it
Create .claude/agents/scout.md:
name: scout description: Research specialist. Use for any task that needs facts, competitor analysis, pricing, market data or audience pain points. Use BEFORE any writing begins. tools: Read, Write, WebSearch, WebFetch model: sonnet
You are Scout, the research specialist on the Launch Team.
Your only job is finding accurate, sourced information. You never write marketing copy. You never give opinions on positioning.
Process
- Read workspace/brief.md to understand what is needed
- Read CLAUDE.md for team rules
- Research using web search and by reading pages directly
- Write your findings to workspace/research.md
Output format for research.md
Key facts
Each fact on its own line with a source link after it.
Competitors
Name, what they offer, price, one weakness. Source for each.
Audience pain points
Real complaints and needs, quoted or paraphrased, with sources (forums, reviews, social posts).
Gaps and unknowns
Anything you could not verify. Be explicit.
Rules
- No source, no fact. Drop anything you cannot cite. * Prefer primary sources (official sites, filings, docs). * Note the date of anything time sensitive. * When done, reply with a 3 line summary and stop.
Note the description line: "Use BEFORE any writing begins." That's a direct instruction to the lead about WHEN to call Scout. Descriptions are routing rules. Treat them that way.
Also note Scout's tools. It can read, write its research file and search the web. It cannot run shell commands or edit other files. Least privilege. Every agent gets only what its job needs.
Step 5: Build Maker, the builder
Create .claude/agents/maker.md:
name: maker description: Writing and building specialist. Use to produce deliverables (landing pages, posts, emails, docs) from an existing brief and research file. Also use to apply fixes from a review. tools: Read, Write, Edit model: opus
You are Maker, the builder on the Launch Team.
You turn a brief and research into finished deliverables. You never do your own research. You only use what is in workspace/research.md.
First draft process
- Read CLAUDE.md, workspace/brief.md and workspace/research.md
- Write the deliverables to workspace/draft.md
- Under each section, list which research facts you used
Revision process
- Read workspace/review.md
- Fix every issue marked HIGH or MEDIUM
- Write the fixed version to workspace/final.md
- At the bottom, list each issue and how you resolved it
Writing rules
- Short sentences. Clear benefits. Specific over vague. * Every number and claim must trace back to research.md * If research is missing something you need, write "[NEEDS RESEARCH: what is missing]" instead of inventing it * No hype words, no fake urgency, no made up testimonials
When done, reply with a 3 line summary and stop.
The [NEEDS RESEARCH] placeholder is a small trick with a big payoff. Instead of hallucinating a stat to fill a gap, Maker flags it. The lead sees the flag and sends Scout back for more.
Maker runs on Opus because writing quality is the product here. If your deliverable is simpler, a lighter model works fine.
Step 6: Build Critic, the reviewer
This is the agent most people skip. It's also the one that makes the biggest difference.
Create .claude/agents/critic.md:
name: critic description: Independent reviewer. Use after any draft is written to check it against the brief and research. Use PROACTIVELY before anything is delivered. tools: Read, Write model: opus
You are Critic, the independent reviewer on the Launch Team.
You did not write this draft. You have no reason to defend it. Your job is to find every problem before a real reader does.
Process
- Read CLAUDE.md, workspace/brief.md, workspace/research.md and workspace/draft.md
- Check every claim in the draft against research.md
- Check the draft against every requirement in the brief
- Write your findings to workspace/review.md
Review format
For each issue: * Severity: HIGH, MEDIUM or LOW * Location: which section and line * Problem: what is wrong * Why it matters: one sentence
HIGH = unsourced claim, factual error, missing brief requirement MEDIUM = weak or vague copy, unclear offer, structural problem LOW = style, word choice, minor polish
End with a verdict: SHIP, FIX THEN SHIP, or REWRITE.
Rules
- Never rewrite the draft yourself. Only flag. * Be specific. "This is weak" is useless. Say why and where. * If the draft is good, say so. Do not invent problems.
Look at the opening line: "You did not write this draft. You have no reason to defend it."
That's the entire point of a separate reviewer. Same model family, completely different job, zero attachment to the work.
And the last rule, "Do not invent problems," matters too. A reviewer told to find issues will find issues, even fake ones. Giving it permission to say "this is good" keeps it honest.
Step 7: Create the one command that runs everything
You could kick off the team by typing a long instruction every time. Don't. Turn it into a command.
Create .claude/commands/launch.md:
Run the full Launch Team workflow for this product idea:
$ARGUMENTS
Follow these steps exactly:
-
Write a clear brief to workspace/brief.md covering: the product, the target audience, the deliverables needed (landing page copy, 3 launch posts, 1 launch email) and what success looks like.
-
Use the scout subagent to research and produce workspace/research.md
-
Read research.md. If there are major gaps, send scout back once with specific questions.
-
Use the maker subagent to write workspace/draft.md
-
Use the critic subagent to review and produce workspace/review.md
-
If the verdict is not SHIP, use the maker subagent to apply fixes and write workspace/final.md. Then use critic once more on final.md.
-
Read final.md yourself end to end. Confirm every claim is sourced and the brief is fully met.
-
Give me: the final package, the list of sources, and anything that still needs my judgment.
Now, inside Claude Code, your entire team runs with one line:
/launch A habit tracker app for remote workers that blocks distracting sites during focus sessions
$ARGUMENTS gets replaced with whatever you type after the command. One idea in. A researched, written, reviewed launch package out.
Step 8: Run it and WATCH the first time
The first run is not for output. It's for learning.
Run the command and watch what happens:
-
Does the lead write a clear brief, or a vague one?
-
Does Scout actually cite sources, or summarize from memory?
-
Does Maker use [NEEDS RESEARCH], or quietly invent things?
-
Does Critic give specific feedback, or generic "make it punchier" notes?
Open every file in workspace/ and read it. This is the superpower of file based handoffs. You can see exactly where the chain broke.
Most first runs have one weak link. Usually it's one of these:
The brief is too thin. Fix: add a brief template to CLAUDE.md with required sections.
Scout goes too broad. Fix: tell it the max number of competitors and facts you want.
Maker ignores the tone. Fix: paste two or three examples of writing you love into its file under a "Style examples" heading.
Critic is too soft. Fix: give it a specific checklist of things to check every time.
Fix ONE thing. Run again. Compare.
This is how you tune a team. Not by rewriting everything. By finding the weakest agent and upgrading just that one.
Step 9: Give each agent memory that compounds
Right now your team starts fresh every run. That's fine for week one. By week three, you want it getting smarter.
Add a notes/ folder and one learnings file per agent:
mkdir notes touch notes/scout-learnings.md touch notes/maker-learnings.md touch notes/critic-learnings.md
Then add this to the bottom of each agent's file:
Learnings
Before starting, read notes/[your-name]-learnings.md After the Lead gives feedback on your work, append one line to that file describing what to do differently next time.
And add this to your CLAUDE.md:
Feedback loop
After every run, if I correct something, write the lesson to the right agent's learnings file in notes/.
Now every correction you make sticks. Tell the team once that your audience hates the word "leverage" and Maker never uses it again. Tell it once that a certain site is unreliable and Scout stops citing it.
This is where a team goes from "useful" to "how did I ever work without this."
Step 10: Lock down permissions
Agents with too many tools are agents that do too many things.
Go back through every agent file and ask: what is the MINIMUM this agent needs?
scout: Read, Write, WebSearch, WebFetch maker: Read, Write, Edit critic: Read, Write
Critic doesn't need to edit files, so it can't. Maker doesn't need the web, so it can't wander off and "research" on its own. Nobody on this team runs shell commands, so nobody gets Bash.
If you later add a coding agent that runs tests, give it Bash. Not before.
This does three things:
-
Keeps agents in their lane. A writer that can't search the web has to use the research.
-
Makes debugging easier. When something goes wrong, there are fewer places it could have happened.
-
Protects your machine. An agent that can't run commands can't run the wrong command.
Inside Claude Code you can also run /agents to view, create and edit your agents and their tool access through a menu, if you prefer that to editing files by hand.
Step 11: Control your costs
Agent teams can burn through usage fast if you're careless. Four agents means four contexts, and a review loop can double it.
Here's how to keep it sane:
Put Opus where judgment lives. The lead, the writer and the critic. These jobs need taste and reasoning.
Put lighter models where volume lives. Research gathering, summarizing, formatting, data extraction. That's why Scout runs on sonnet in our setup. For pure grunt work like reformatting files, haiku is often enough.
Cap the loops. Our command says "send scout back ONCE" and "use critic once more." Without caps, a lead can keep looping trying to reach perfection.
Keep agent files tight. Every word in an agent's system prompt gets read on every call. Cut anything that isn't changing behavior.
Reuse research. If you're launching three products in the same market, have Scout write to a shared research file you reuse instead of researching from scratch every time.
A rough rule I use:
Strong model: planning, writing, reviewing, final decisions Lighter model: searching, collecting, summarizing, formatting
Step 12: Run work in parallel
Once your team works in sequence, unlock the next level: parallel work.
Some tasks don't depend on each other. Scout can research competitors while a second Scout researches audience pain points. Maker can write the email while another Maker writes the posts.
Just tell the lead. Add this to your command:
For research, run two scout subagents in parallel: * One researches competitors and pricing * One researches audience pain points and language Each writes to its own file: workspace/research-competitors.md and workspace/research-audience.md. Then merge both into workspace/research.md before writing begins.
Same agents. Same rules. Half the wall clock time.
Don't go wild here on day one. Parallel work is powerful, but it multiplies cost and makes debugging harder. Get the sequential version solid first.
The 7 mistakes that kill agent teams
I've watched a lot of people build their first team. These are the patterns that break them.
1. Too many agents too soon.Ten agents with fuzzy roles perform worse than three with sharp ones. Start with three or four. Add one only when you can name the exact job no current agent does well.
2. Overlapping roles.If two agents could both reasonably take a task, the lead will pick randomly and you'll get inconsistent results. Every task type should have exactly ONE owner.
3. Vague descriptions.The lead routes work based on each agent's description. "Helpful assistant for content" tells it nothing. "Use after any draft is written to check claims against research" tells it exactly when.
4. No reviewer.A team without a critic is just a faster way to produce unchecked work. The reviewer is the cheapest quality upgrade you will ever make.
5. Passing everything through chat.If agents hand work to each other only through conversation, context bloats and things get lost. Write to files. Read from files.
6. No definition of done.If the lead doesn't know what finished looks like, it either stops too early or never stops. Write it down in CLAUDE.md.
7. Never reading the output.An agent team is leverage, not abdication. The final step of every run is YOU reading the result. The team does 90% of the work. Your judgment is the last 10%, and it's the 10% that matters.
Where to take your team next
Once your Launch Team runs clean, you have a template for anything.
Swap the specialists and you get a completely different team with the same skeleton.
Content Team
scout: finds trending topics and sources in your niche maker: writes the thread, newsletter and short post critic: checks hooks, facts and tone against your style guide
Code Review Team
reader: maps what the change does and what it touches tester: writes and runs tests for the changed code critic: flags bugs, security issues and missing edge cases
Research Team
scout A: gathers primary sources scout B: gathers opposing views and counter evidence analyst: synthesizes both into a balanced brief critic: checks every claim has a source and flags bias
Sales Prep Team
scout: researches the prospect company and decision maker maker: writes a tailored outreach email and call notes critic: checks for generic lines and unverified assumptions
Same folder structure. Same CLAUDE.md pattern. Same file handoffs. Same command.
Build the skeleton once. Reuse it forever.
The copy and paste starter kit
Here's everything in one place so you can set up a team in five minutes.
Folder setup:
mkdir my-team && cd my-team mkdir workspace notes .claude .claude/agents .claude/commands touch CLAUDE.md
Agent template (save as .claude/agents/[name].md):
name: [agent-name] description: [What it does]. Use when [exact situation]. Never use for [what it should not do]. tools: [only the tools it needs] model: [opus or sonnet or haiku]
You are [Name], the [role] on the [Team Name].
Your only job is [one sentence job]. You never [the job that belongs to someone else].
Process
- Read CLAUDE.md and notes/[name]-learnings.md
- Read [input files]
- [Do the work]
- Write output to workspace/[output file]
Output format
[Exact structure you want]
Rules
- [Rule that prevents the most common mistake] * [Rule that keeps it in its lane] * If unsure, say so. Never guess.
When done, reply with a 3 line summary and stop.
Command template (save as .claude/commands/[name].md):
Run the [Team Name] workflow for:
$ARGUMENTS
- Write a brief to workspace/brief.md
- Use the [agent 1] subagent to [job] and write [file]
- Use the [agent 2] subagent to [job] and write [file]
- Use the [critic] subagent to review and write workspace/review.md
- If the verdict is not SHIP, apply fixes once and review once more
- Read the final output yourself and confirm it meets the brief
- Give me the result and anything that needs my judgment
Fill in the brackets. Run the command. Watch it work.
The real shift
Here's what changes once you build your first team.
You stop thinking "what should I ask the AI?"
You start thinking "who on my team should handle this?"
That's a different mindset. It's the mindset of a manager, not a user. And it's the one that's going to separate people who use AI from people who run on it.
A year ago, a solo founder needed a researcher, a writer, an editor and a project manager to ship a launch like this.
Today it's four markdown files and one command.
The people who figure this out early are going to look like they have a team of ten.
They'll have a team of four.
And none of them will be human.
Build yours this week. Start with one workflow. Three or four agents. One command.
Then make it better every single run.
If you want to master AI agents and actually put them to work, follow @cyrilXBT. I break down the tools, setups and workflows that are working right now, with every prompt included.
Save this guide. You'll want it open when you build your second team.
沿着这个主题继续读
从一篇文章,找到相关的教程、经验和阅读路径。



