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.

If you're wondering how agents differ from skills (Module 6): a skill is a recipe for a specific task. An agent is a specialist you hire for a domain. Skills are narrow and precise; agents are broad and adaptive.

Claude Code comes with built-in subagents that work out of the box — you don't need to install anything:

• Explore — a fast, lightweight agent for searching your codebase and answering questions about it
• Plan — a read-only research agent that helps you think through approach before writing code
• general-purpose — a full-capability agent for complex multi-step tasks

These built-in agents run automatically when Claude decides a task benefits from delegation. You don't need to manage them.

Beyond the built-ins, you can create custom agents in ~/.claude/agents/ as plain text files (the same .md files you've been working with since Module 5). The setup we provide includes around 20 additional agents that cover common specialisations. Use the /agents command to create, edit, and manage your agent library.

What you get:

Plus 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

## Rules
- 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. This follows the same process as building skills (Module 6). If you've built a skill, you can build an agent — same process, broader scope. Remember the distinction from earlier: 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].

## Core Capabilities
- [Capability 1]
- [Capability 2]
- [Capability 3]

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

## Rules
- [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.