How Claude Code Builds an Entire Outbound Campaign in Under 20 Minutes

Building an outbound campaign from scratch is a multi-hour operation. You pull a company list, research each account, score them against your ICP, find contact information, write personalized emails, and upload everything into your sending platform. Most of that time is spent on repetitive data work, not strategy.

We ran a live demo where Claude Code handled the entire workflow in a single terminal session. Kenny Damian fed it a list of companies, wrote a few prompts, and Claude Code took over. It scored the list, found emails, wrote personalized copy, and uploaded the campaign into Instantly. The whole process took fewer than 20 minutes.

Here is exactly how each step works and why this changes the GTM workflow permanently.

1. Why Outbound Campaign Building Takes Too Long

A typical outbound campaign involves five distinct phases: list building, ICP scoring, email enrichment, copy personalization, and campaign upload. Each phase requires a different tool, a different interface, and a different skill set.

List building happens in Clay or a data provider. Scoring happens in a spreadsheet or a custom formula. Email finding goes through Apollo, Prospeo, or FullEnrich. Copy gets written manually or through templates. Then everything gets formatted and uploaded to Instantly or lemlist.

Each transition between tools introduces friction. You export a CSV, reformat columns, clean data, paste it somewhere else, and repeat. A single campaign for 500 leads takes 3 to 5 hours of manual work before a single email goes out.

The problem is not any individual step. The problem is the number of handoffs between them. Every handoff is a place where data gets lost, formatting breaks, or someone makes a copy-paste error.

Claude Code eliminates the handoffs entirely. It runs the complete pipeline inside one session, calling APIs directly, processing data in memory, and pushing the final output to your sending platform without ever leaving the terminal.

If you want to brainstorm campaign angles before building, you can generate ideas based on your ICP and offer, for free:

Campaign Ideation Tool

2. ICP Scoring With AI

The first thing Claude Code did was score and prioritize the entire company list using ready to test campaign ideas against our ICP criteria.

We defined the scoring rules in the prompt: industry fit, company size, growth signals, tech stack indicators, and relevance to what we sell. Claude Code read through every company in the list and assigned a priority score based on those criteria, using verified emails in bulk where available.

This is not simple keyword matching. Claude Code understands context. A company with 50 employees that just raised a Series A and is hiring three SDRs scores differently than a 50-person company that has been flat for two years. The model weighs multiple signals together the way a senior sales rep would, but across hundreds of accounts simultaneously.

The output was a ranked list. Tier 1 accounts at the top, lower-priority accounts at the bottom. This ranking then determined how much personalization effort each account received in the copy generation step.

What makes this different from building a scoring model in Clay is speed of iteration. If the scoring criteria need to change, you update the prompt. No formula rebuilds. No column reconfiguration. You describe what a good-fit account looks like in plain English, and Claude Code applies it.

For teams running multiple campaigns per week, this cuts the list qualification step from 45 minutes to under 3 minutes.

3. Waterfall Email Enrichment

Once the list was scored, Claude Code needed verified email addresses for each contact. This is where the waterfall enrichment pattern comes in.

The first call went to Apollo's API. Apollo has one of the largest B2B contact databases, and for many accounts it returned a verified email on the first try. But no single provider has 100% coverage. For the contacts Apollo missed, Claude Code automatically moved to the next enrichment provider.

This is the waterfall approach we use at ColdIQ across all campaigns. You start with your highest-confidence provider and cascade through alternatives for the gaps. The sequence might look like this:

→ Apollo as the primary source (largest database, fast API)

→ Prospeo for contacts Apollo missed (strong on European domains)

→ FullEnrich as a third-pass provider (aggregates multiple sources)

→ Wiza or LeadMagic for remaining gaps

Each provider returns different confidence levels. Claude Code filters out low-confidence results and only keeps verified addresses. The result is a clean contact list with the highest possible coverage rate, built automatically in minutes.

Manually, this process involves exporting unmatched contacts from one tool, uploading them to another, downloading results, merging spreadsheets, and deduping. With Claude Code, it is a single loop in the script. If provider A returns nothing, try provider B. If B returns nothing, try C. No manual intervention.

You can find verified email addresses for any contact using the same providers we use, for free:

Email Finder Tool

4. AI-Generated Copy That Converts

With a scored list and verified emails, Claude Code moved to writing the outreach sequences. This is where it gets interesting.

We did not ask Claude Code to write cold emails from scratch. We fed it our best-performing outreach templates as reference material. These are sequences that have generated millions in pipeline across dozens of campaigns. The prompt included our copywriting rules: under 100 words per email, no jargon, subject lines that convert and look like they came from a colleague, yes/no CTAs, and a first line that answers "why you, why now."

Claude Code generated personalized copy templates with dynamic variables. Each email referenced specific details about the target company. For a SaaS company that just raised funding, the opening line mentioned the raise. For a company hiring SDRs, it referenced the hiring signal. Different triggers produced different copy variations, all within the same campaign structure.

The sequence format followed our standard pattern:

→ Email 1: New thread, trigger-based opening, problem statement, soft CTA

→ Email 2: Threaded reply to E1, short follow-up with a different angle

→ Email 3: New thread, case study or social proof, direct CTA

→ Email 4: Threaded reply to E3, breakup email, final ask

Each email included fallback copy for cases where a dynamic variable was empty. If the funding amount was not available, the email still worked with a generic but relevant opening. This is critical. Personalization that breaks when data is missing is worse than no personalization at all.

The copy was not perfect out of the box. Some lines needed tightening. A few CTAs could have been sharper. But it was 85% of the way there, and the editing pass took 10 minutes instead of the hour it would take to write four emails from scratch for each segment.

5. One-Click Campaign Upload to Instantly

The final step was pushing everything into Instantly. Leads, email sequences, sending schedules, and campaign settings.

Claude Code used Instantly's API to create the campaign, upload the lead list with all enriched fields, attach the email sequences, and configure the sending parameters. What normally requires 20 minutes of clicking through the Instantly UI happened in a single API call.

The campaign was live and ready to send. Leads were tagged by ICP tier so performance could be tracked by segment. The sequences were properly threaded so Email 2 appeared as a reply to Email 1 in the recipient's inbox. Sending limits and schedules were set according to our deliverability standards.

This is the step most teams underestimate. Uploading a campaign is not hard, but it is tedious. Mapping CSV columns to platform fields. Setting up sequences in the right order. Configuring reply tracking. When you run 10 or 15 campaigns per month, the cumulative upload time adds up to hours of repetitive work every week.

With Claude Code handling the API integration, that time drops to zero. The campaign goes from scored list to live in Instantly without anyone touching the platform UI.

If you want to check whether your email copy and sending setup will land in the inbox before you launch, you can test it for free:

Spam Checker Tool

6. What This Means for GTM Teams

The demo was not a proof of concept. It was a production workflow running on real data with real APIs.

Here is what changes when you automate campaign building this way:

→ A single GTM engineer can launch 5 to 10 campaigns per week instead of 2 to 3

→ ICP scoring becomes a prompt change, not a formula rebuild

→ Email enrichment waterfalls run automatically without manual CSV exports

→ Copy generation produces drafts that need editing, not blank-page creation

→ Campaign upload is an API call, not 20 minutes of clicking

The role shifts from execution to oversight. Instead of spending 4 hours building one campaign, you spend 20 minutes reviewing and tweaking the output of an automated build. The human judgment is still there. It is just applied at the editing layer instead of the assembly layer.

This also changes hiring. A team that needed three people to manage campaign operations can now do the same volume with one person and Claude Code. That person needs to understand ICP design, copy principles, and deliverability. But they do not need to spend their days on data manipulation and platform uploads.

For agencies like ours, this means more campaigns, faster turnaround, and better quality control. For in-house teams, it means your senior people stop doing junior work.

‍

7. Conclusion

The outbound campaign workflow has not changed much in the last five years. The tools got better, the data got richer, but the process stayed manual. You still pull lists, score accounts, find emails, write copy, and upload campaigns one step at a time.

Claude Code compresses that entire chain into a single terminal session. It is not replacing the strategy. It is replacing the execution layer between strategy and live campaign. You still decide who to target, what to say, and how to position the offer. Claude Code handles the 4 hours of data work in between.

The teams that adopt this workflow will operate at a fundamentally different speed than those still building campaigns manually. Not because the emails are better. Because they can run 5x more campaigns in the same time, test more angles, and iterate faster on what works.

The campaign building bottleneck is gone. What matters now is the quality of your strategy, your targeting, and your offer. The execution is automated.