Claude Unpacked: Subagents

I am doing a short email series called Claude Unpacked, where I go through parts of Claude that marketers might not have used yet.

Last time, I covered slash commands and Skills.

This week, it’s subagents.

These are part of Claude Code, so if you only use Claude in the normal chat window, you may not have seen them.

As usual, if you find any value in these newsletters, do me a favor and share the link.

A subagent is a specialist assistant inside Claude Code.

You give it a specific task. Claude sends the task to that subagent. The subagent works through it and returns the result to your main conversation.

So instead of asking one Claude thread to do everything, you can split off parts of the work.

For example, say you are writing a landing page.

Each one has its own specialist role.

That is the bit people get wrong. A subagent shouldn’t be a general assistant.

It should be something like:

The more specific the role of a subagent, the more controlled the output will be.

Skills and subagents are related, but they aren’t the same thing.

A Skill is a reusable instruction. A subagent is a separate worker.

The Skill runs inside the main conversation. The subagent runs in its own context window and sends the answer back.

So you should be using Skills when you repeat the same task, and subagents when the task has a lot of side work.

A Skill is good for:

A subagent is good for:

You can use both together. A Skill can create the asset, and your subagent can review it.

You can keep everything in one Claude conversation. For small tasks, that is usually fine.

The problem starts when the work is more complex.

A landing page project can turn into:

All of that would be discussed in the same thread.

Which is important because Claude has a context window. The context window is the amount of information Claude can keep in view while it works.

When the thread gets full, Claude has more to sort through every time you ask for the next step. That’s when it starts missing earlier decisions, repeating old points, or pulling from notes you don’t need. It also burns through more tokens.

Subagents help because you can send one part of the work away to be more focused and dedicated.

Your main thread doesn’t need every detail from those checks. It only needs the output.

The point is to make the workflow more structured and reliable.

This is all managed inside Claude Code.

You don’t need to write the files manually to start. The simple method is to use Claude’s built-in subagent screen.

Subagents are created from the terminal, not the desktop app. Ppen Terminal (Mac) or PowerShell (Windows), type claude to start a session, then type /agents.

Then choose to create a new subagent.

Claude will ask for the main details:

The description is important because Claude uses it to understand when the subagent should be used.

So don’t write something unclear like ‘helps with content’.

Write something clearer like: ‘Use this after a marketing draft is written. Check for unsupported claims, repeated points, missing proof, unclear examples, and lines that do not match the approved style. Return a short list of issues. Do not rewrite the full draft unless asked.’

Then choose the tools it can use. Keep this aligned with the task.

Don’t give every subagent every tool just because the option is there.

It’s also important to choose which model the subagent runs on.

A heavy reviewer might want a stronger model, but a simple QA or research subagent can run on a smaller, faster one like Haiku.

That keeps the cost down and the checks quick, which fits the whole point of moving side work off your main thread.

Subagents can sit in two places.

These are available across your own Claude Code projects. Use these for repeatable roles you want to use often.

These sit inside a specific project folder, under: .claude/agents/

Use these when the subagent only applies to one brand, product, site, or client.

Not every project should use the same rules.

A general QA checker might be useful everywhere. A brand voice checker should usually stay inside that brand’s project.

Once the subagent exists, you can use it in two ways.

Claude can call it automatically when your task matches the description or you can ask for it directly.

For example: Use the marketing-qa-checker subagent to review this email before it goes live.

You can also mention a specific subagent with @ in Claude Code.

The main thing is to point the subagent at the right asset.

Not: Improve this.

But: Use the marketing-qa-checker subagent to review newsletter-draft.md.

The checklist should already live inside the subagent. If you have to retype the full checklist every time, the subagent isn’t setup correctly.

Use this when you have survey responses, sales notes, reviews, support tickets, or call transcripts.

Point the subagent at the raw material and let it return the repeated objections, phrases, pain points, buying triggers, and missing proof.

That keeps the raw notes out of the main thread.

Use this when you need several pages checked without turning the main conversation into a research dump.

Point the subagent at competitor homepages, pricing pages, ads, or product pages.

It should return the positioning patterns, claims, proof, offers, and gaps.

Useful when you have a folder of old posts, landing pages, or campaign assets.

The subagent can scan the set and return which pages are outdated, duplicated, thin, off-brand, missing internal links, or worth updating.

You don’t need every note in the main conversation, only the priority list.

Use this when you are working on a landing page, email sequence, ad campaign, or sales page.

The subagent checks whether the message matches the audience.

It can look for vague pain points, unclear objections, weak proof, missing use cases, or sections that sound like they were written for the company instead of the buyer.

Use this at the end.

The subagent checks the boring things that are easy to miss:

So that’s subagents. Use them to keep your main conversation focused on the work, and hand the side tasks to specialists that report back with just the output. 

You don’t need a dozen of them to start. Pick one task you always repeat, like a publishing QA check, build a single subagent for it, and point it at your next draft. Once that clicks, the rest will follow