Cold Email with Claude Code: Skills, Subagents & cold.md

Lesson 9.1 - Why Cold Email Is the Perfect AI Agent Use Case

The first eight modules of this course showed you how to do cold email by hand. This module shows you how to hand the steering wheel to a model.

The reason cold email is unusually well-suited to AI agents is the structure of the job. Every step has a clear input, a clear output, and a clear success metric:

These are deterministic enough that an LLM doesn't have to invent the workflow — it just has to make judgment calls inside a known pipeline. The platform (FoxReach) handles the deterministic parts. The agent handles personalization, classification, and refinement.

That split is what makes the system reliable. The agent never has to remember "send the email at 9am Tuesday" because that's the platform's job. It just has to write a good email.

What gets unlocked when an agent runs the loop

• Personalization at scale that doesn't degrade with volume
• Reply handling at human latency without humans
• Continuous improvement: the agent reads its own results and adjusts copy + targeting
• A non-trivial % of meetings booked while you sleep

This module shows you how to build that.

Lesson 9.2 - Anatomy of a Claude Code Skill

A Claude Code skill is a folder of markdown that teaches an agent how to do one thing. The agent loads the skill on demand, follows the instructions, and uses the tools the skill describes.

The simplest possible skill looks like this:

my-skill/
├── SKILL.md          ← teaches the agent the procedure
└── README.md         ← documentation for humans

SKILL.md has frontmatter that lets the agent decide whether to invoke the skill, plus the body that walks through the actual procedure:

---
name: cold-email-outreach
description: Use when the user wants to send cold email — runs list-building, copywriting, sequencing, and reply triage end-to-end via FoxReach.
---

# Cold Email Outreach

You are running a cold email campaign on behalf of the user. Follow this procedure exactly.

## Step 1: Confirm the campaign brief
[...]

That's it. No SDK install, no orchestration framework, no platform lock-in. The agent reads the markdown and runs.

Why cold email needs its own skill

Generic agents fail at cold email because they don't know:

• What "good" copy looks like in B2B vs consumer
• Why subject lines under 6 words outperform clever ones
• That two follow-ups doubles the reply rate but five triggers spam complaints
• How to read a reply and route it (interested / not now / unsubscribe / referral / forwarded)
• When to stop sequencing because the lead replied positively

Encode all of that into a skill once, and every conversation with the agent inherits the institutional knowledge from the rest of this course.

Cross-reference: the entire course up to this point — modules 2 through 8 — is the source material for what goes inside the skill body. The deliverability rules from Module 2, the warmup ramp-up from Module 3, the copywriting frameworks from Module 5 — they all become procedural instructions inside the skill.

Lesson 9.3 - The cold.md Spec

cold.md is a small open spec for describing a cold email campaign as plain markdown. It exists so an AI agent — or a human, or a script — can read one file and know exactly what to send, who to send it to, and how to follow up.

Why a spec instead of a config file

Cold email tools each invented their own JSON schema. The result was that copy written for one tool couldn't be moved to another, and an agent couldn't author campaigns without learning a new shape every time.

cold.md treats a campaign the way Markdown treats a document: a single readable file with frontmatter and prose. Anything that can read markdown can read a campaign.

A minimal cold.md file looks like this:

---
campaign: q1-cto-outreach
icp:
  - title: CTO, VP Eng
  - company: Series A-C SaaS, 50-500 employees
  - geography: North America, EU
sending:
  daily_limit: 50
  start_hour: 9
  end_hour: 17
  timezone: prospect
sequence:
  - delay_days: 0
    template: opener
  - delay_days: 3
    template: bump
  - delay_days: 7
    template: breakup
---

## opener

Hey {first_name},

Saw {company} just shipped {recent_product}. Quick question — how's
{specific_pain} for the engineering team right now?

Most CTOs at companies your size handle this with one of three approaches —
happy to walk through which is working for {industry} teams in 2026.

Worth a 15-min call?

— Usama

## bump

Bumping this up — did you see my note about {specific_pain}?
[...]

That single file is enough for an agent to:

1. Build a list matching the ICP
2. Render each template against each lead
3. Schedule the sequence with correct delays
4. Push the whole thing to a sending platform

What cold.md is not

It's not a runtime. It doesn't send anything. It's a description that other tools (FoxReach, Instantly, manual workflows) can act on.

That separation is the point. The same cold.md file should be portable across senders.

The cold.md repository: github.com/concaption/cold-md. Open spec, free Claude Code skill, and a free FoxReach plugin that reads cold.md files and provisions campaigns automatically.

Lesson 9.4 - FoxReach MCP — Your Campaigns as Agent Tools

MCP — Model Context Protocol — is the standard for giving an agent tools it can call. FoxReach ships an MCP server that exposes every action you'd take in the FoxReach UI as a typed tool.

When an agent connects to the FoxReach MCP server, it can:

• Create a campaign
• Add a sequence step
• Import leads from a CSV or a JSON array
• Assign sending accounts
• Pause / resume / archive a campaign
• Read inbox replies
• Send a reply
• Read campaign analytics

Each of these is a tool the agent can call as naturally as a Python function. The MCP server validates inputs against your account, applies your daily limits, and returns structured responses the agent can reason over.

Connecting an agent to FoxReach MCP

In Claude Code, the connection is one entry in your mcp.json:

{
  "mcpServers": {
    "foxreach": {
      "command": "npx",
      "args": ["-y", "@foxreach/mcp"],
      "env": {
        "FOXREACH_API_KEY": "fr_live_..."
      }
    }
  }
}

Once that's set, the agent has access to the full FoxReach API as tools. Combined with the cold-email-outreach skill from Lesson 9.2, the agent can author + execute campaigns inside one conversation.

The "platform-as-tool" pattern

Don't make your agent re-implement what the platform already does. The agent's job is judgment, not execution.

The agent stays focused on writing good copy, building good lists, and reading replies well.

Lesson 9.5 - Subagent Patterns

A single agent doing the whole job works. A subagent-per-role design works better.

The reason is that each part of cold email rewards different prompts and different context. A list-building subagent benefits from access to web search, LinkedIn data, and CRM lookups. A copywriter benefits from access to past high-performing emails and the brand's tone. A reply triager benefits from a tight classification taxonomy and almost nothing else.

Mixing these in a single prompt creates a generalist that's mediocre at all three.

The three subagents

list-builder Takes an ICP definition, returns verified contacts. Has tools for: web search, LinkedIn lookups, NeverBounce verification, FoxReach lead import.

copywriter Takes a lead + offer + tone, returns a personalized email. Has access to: prior high-reply-rate emails, the brand's voice guide, the cold.md template library.

reply-triager Takes an inbound reply + thread context, returns a category and a draft response. Has tools for: FoxReach inbox read, FoxReach reply send, suppression list update, calendar booking.

Orchestration

The parent agent (your main Claude conversation) coordinates. It does not write copy, build lists, or triage replies — it dispatches subagents and assembles the results.

You: "Run my Q1 CTO outreach"
   │
   ▼
Parent agent reads campaigns/q1-cto-outreach.cold.md
   │
   ├─→ list-builder subagent
   │     • returns 200 verified leads
   │
   ├─→ copywriter subagent (per lead, in parallel)
   │     • returns personalized emails
   │
   └─→ FoxReach MCP
         • creates campaign
         • assigns leads
         • schedules sequence

Reply received later
   │
   ▼
reply-triager subagent
   • categorizes (interested / not now / referral / unsub)
   • drafts response
   • parent confirms send via FoxReach MCP

This is a real architecture, not a thought experiment. We run it ourselves on FoxReach campaigns.

Lesson 9.6 - The Self-Improving Outreach Loop

The biggest unlock in agentic cold email is that the agent reads its own output.

Every reply the campaign generates is training data. Every bounce is a lesson about list quality. Every "not interested" with a specific reason is a clue about messaging fit.

Encode that feedback into a weekly loop:

The weekly improvement cycle

1. Pull last week's analytics via FoxReach MCP — open rate, reply rate, positive reply rate, bounce rate per template variation
2. Pull a sample of replies — 20 replies per category (interested, not now, referral, unsub, complaint)
3. Diagnose — the agent reads the data and writes a markdown diagnosis: which templates worked, which didn't, what the pattern is in the "not now" replies, what the unsubscribe reasons are saying
4. Propose changes — the agent updates the cold.md template variants, suppression rules, or ICP definition with reasoning
5. Human review — you read the diagnosis + proposed diff, approve or adjust
6. Apply — the agent updates the campaign via FoxReach MCP

This is not "AI replacing the operator". It's the operator giving the AI the boring half of the analyst job — the data-pull + pattern-recognition — and keeping the strategic half.

After three or four cycles, the campaign is materially better than what you'd write by hand on day one. Not because the model is smarter than you, but because it actually does the analysis every week instead of letting it slip.

What to feed back

Module 8 of this course covered the metrics. This lesson is about closing the loop — having the agent act on them.

Cross-reference: review Module 8: Cold Email Metrics & Benchmarks for the full set of KPIs the agent should pull and what each one means.

Lesson 9.7 - Putting It Together: A Working Blueprint

Here's the working architecture, end to end:

┌─────────────────────────────────────────────────────────────┐
│                  YOUR CLAUDE CODE SESSION                    │
│                                                              │
│  ┌───────────────────────────────────────────────────────┐  │
│  │  Skill: cold-email-outreach (cold-md skill)           │  │
│  │  • The procedure for running outreach end-to-end      │  │
│  └───────────────────────────────────────────────────────┘  │
│                                                              │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐       │
│  │ list-builder │  │ copywriter   │  │ reply-triager│       │
│  │ subagent     │  │ subagent     │  │ subagent     │       │
│  └──────────────┘  └──────────────┘  └──────────────┘       │
│                                                              │
└─────────────────────────────────────────────────────────────┘
            │                   │                  │
            ▼                   ▼                  ▼
    ┌──────────────────────────────────────────────────────┐
    │           FoxReach MCP Server (tools)                │
    │  campaigns · leads · sequences · inbox · analytics   │
    └──────────────────────────────────────────────────────┘
            │
            ▼
    ┌──────────────────────────────────────────────────────┐
    │              FoxReach platform (sender)              │
    │   sending · deliverability · warmup · suppression    │
    └──────────────────────────────────────────────────────┘
            │
            ▼
    Inbox of your prospect

What you set up once

1. Install Claude Code (claude)
2. Add the FoxReach MCP server to mcp.json with your API key
3. Install the cold-email-outreach skill (claude skill add github.com/concaption/cold-md)
4. Connect your sending domains and warm them up via Module 3

What you do per campaign

1. Author a <name>.cold.md file with the ICP, sequence, and templates
2. Open Claude Code, drop the file in, say "run this campaign"
3. Review the agent's diagnosis after each weekly cycle

That's the whole loop. The hard parts — the deliverability, the warmup, the inbox placement — are handled by the platform. The judgment parts — the targeting, the copy, the response handling — are handled by the agent. You're the editor.

Where to start

If you've finished modules 1 through 8, you already have the practitioner's understanding to define the cold.md correctly. The skill won't write good campaigns for you if you can't write good campaigns yourself — but with that foundation, the skill multiplies your output.

Clone github.com/concaption/cold-md, read the README, and ship your first agentic campaign.

Module 9 Quiz

1. What's the split of responsibilities between the agent, the FoxReach platform, and the human operator?
2. Why use subagents instead of one agent for the whole pipeline?
3. What does cold.md describe — and what does it deliberately NOT do?
4. What's the role of the FoxReach MCP server in this architecture?
5. Name three signals from the weekly loop that should trigger a campaign change.