Agents — Your Team of Specialists

In every module so far, you've been talking to one Claude. One conversation, one assistant, one perspective.

Agents change that. An agent is a separate Claude instance with specialised instructions for a specific domain. When your main Claude encounters a task that requires specialised knowledge — say, designing a database schema, reviewing code quality, or writing a professional document — it can delegate that task to an agent that's been specifically configured for it.

Think of it this way: your main Claude is a capable generalist. Agents are the specialists it can call in when the task demands expertise.

What agents aren't: They're not separate AI systems. They're not a team of humans. They're not different AI models. They're the same Claude, but with different instruction sets loaded. The same way you become more effective when you read a domain-specific manual before starting a task, Claude becomes more effective when it loads domain-specific agent instructions.

Agents live in ~/.claude/agents/ as markdown files. The setup we provide includes around 20 agents that cover the most commonly needed specialisations. They're available in every session without any extra configuration.

What you get:

• Copy Editor — for polishing written content
• Research Synthesiser — for aggregating information from multiple sources
• First Principles Analyser — for breaking down complex problems
• Professional Writing Coach — for business writing across formats
• Brainstorm Orchestrator — for generating creative solutions through multiple perspectives
• Deep Web Researcher — for comprehensive multi-source research
• Code Quality Guardian — for code reviews and refactoring (if you write code)
• Debugging Expert — for diagnosing issues (if you write code)
• And about a dozen more covering design, project management, and analysis

These cover the tasks that come up most frequently across different types of work. You don't need all of them — but having a specialist ready when you need one is consistently better than asking general-purpose Claude.

How to use agents

You can ask Claude to use a specific agent directly:

Use the copy editor agent to review this blog post.

Claude loads that agent's instructions and delegates the task with full context about your request.

You can also let Claude decide. When it encounters a task that would benefit from a specialist, it checks what agents are available and routes the task to the best fit. You don't always need to pick — but you can if you want to.

Each agent is a markdown file in ~/.claude/agents/ containing specialised instructions. Here's what one looks like:

Example: `~/.claude/agents/copy-editor.md`

---
name: Copy Editor
description: Polish and refine written content for clarity, conciseness, and impact
---

# Copy Editor

You are a meticulous copy editor. When reviewing text:

1. Fix grammar, spelling, and punctuation errors
2. Tighten loose writing — remove unnecessary words
3. Improve sentence flow and readability
4. Flag inconsistencies in tone, terminology, or formatting
5. Suggest stronger alternatives for weak phrases

• Preserve the author's voice. Edit for clarity, not style.
• Show specific changes, don't just describe problems.
• Prioritise the changes with the most impact on readability.
• If the writing is genuinely good, say so. Don't manufacture edits.

### What makes a good agent

A good agent file has:

1. **A clear scope.** What this agent handles and (implicitly) what it doesn't.
2. **A specific process.** The steps it follows, in order.
3. **Rules that prevent common mistakes.** Quality constraints, format requirements, safety checks.
4. **A persona that shapes the output.** "Meticulous copy editor" produces different output than "casual writing helper."

A bad agent file is either too vague ("help with writing") or too long (2,000+ words of instructions). Aim for 150-400 words of focused, specific instructions.

---

The 20-odd agents we provide are a strong starting point, but they won't cover everything. The good news: creating your own agents follows the exact same pattern you just saw. If you find yourself repeatedly wanting a specialist Claude doesn't have, create one.

A few ideas for agents you might build over time:

• An agent for your specific industry (real estate analysis, academic writing, e-commerce copy)
• A client-specific agent that knows a particular client's brand voice and preferences
• A workflow agent that chains multiple steps together (research → outline → draft → review)

Agents add value when:

• The task requires domain-specific frameworks (database normalisation, pricing strategy, code review checklists)
• The task benefits from a consistent, repeatable process (copy editing follows the same steps every time)
• You want a specific perspective (a security auditor looking for vulnerabilities thinks differently than a general-purpose coder)
• The task is complex enough to benefit from specialisation (designing a system architecture vs answering a quick question)

Agents don't add value when:

• The task is simple and straightforward
• You need a quick answer, not a thorough analysis
• The task is so unique that generic instructions are as good as specialised ones
• You'd spend more tokens loading the agent than the agent saves

A practical rule: if you'd hire a specialist for this task in real life, an agent is probably worth it. If you'd handle it yourself, regular Claude is fine.

You've seen the pattern. An agent is a markdown file with a name, description, and instructions. Creating your own follows the same process as creating skills — but instead of task-specific instructions, you're creating role-specific instructions.

When to create an agent vs a skill

| | Skill | Agent | |--|-------|-------| | Scope | One specific task | A role with many tasks | | Trigger | You invoke it with a slash command | Claude routes to it when the domain matches | | Example | /summarise — summarise this document | Research Synthesiser — aggregate findings across multiple sources | | Analogy | A recipe | A specialist you hire |

Create a skill when you have a specific, repeatable task. Create an agent when you have a domain that benefits from consistent specialised thinking.

The template

---
name: [Agent Name]
description: [One line — used for routing, so be specific about what this agent does]
---

# [Agent Name]

You are a [role description with 10+ years experience in relevant domain].

• [Capability 1]
• [Capability 2]
• [Capability 3]

1. [How this agent approaches tasks]
2. [What it does first, second, third]

• [Quality constraints]
• [What to avoid]
• [Format requirements]

### Testing agents

After creating an agent:

1. Ask Claude to use it on a real task: "Use the [agent name] agent to help me with [task]"
2. Check whether the output reflects the specialised instructions
3. Compare it to what Claude produces without the agent — is there a meaningful difference?
4. If not, either the instructions need to be more specific, or this task doesn't benefit from an agent

---

Let's be transparent:

• Agent files don't cost tokens until they're used. Claude reads their names and descriptions from the directory, but only loads the full instructions when it routes a task to one.
• Individual agent files: ~200-500 tokens when loaded
• Total typical cost: 200-500 tokens per agent use

Compare this to the alternative: giving Claude the same specialised instructions manually each time (you'd type them out, costing tokens from your side, and probably miss important details).

Agents are a fixed token cost for consistently better output. The same economics as skills, but at a higher level of abstraction.

You now have a team. A generalist Claude for everyday work, backed by 20+ specialists you can call on when a task demands depth. Your CLAUDE.md tells Claude how to behave. Your skills tell it how to perform tasks. Your hooks automate the background. Your memory persists context. And now your agents give it specialised expertise.

One module left. Module 10 ties everything together — external tools, domain rules, and the big picture of how all these pieces compose into a system that works.