How to Run Your Entire Outbound From One Claude Code Command

Cover image

A single Claude Code terminal can run your whole outbound loop end to end. It pulls a company list, scores every lead against your ICP, profiles each account, writes a personalized opener, builds the sequence, and pushes it into your sequencer. One command does all of it.

The mechanism is hooks.

When one stage finishes, a hook fires the next on its own, so nothing waits on you to export a file or switch a tab. What follows is the entire build: the repo, the five agents that make up the pipeline, the 1-to-100 scoring rubric they run on, and the hooks that chain them together. Clone it, drop in your keys, and run it on a real list the same afternoon.

I have built the go-to-market systems behind 275+ B2B companies. This is the setup itself, step by step, not a pitch for one.

What the loop produces

You point the pipeline at a CSV that has, at minimum, a column of company names. From there it runs five agents in order, and each one writes its output to a file the next agent reads.

output/0-enriched.csv     # web-researched fields, only if your input was sparse
output/1-signals.csv      # buying signals per company, sorted HIGH → LOW
output/2-prioritized.csv  # a 1-100 score, a tier, and the reasoning behind it
output/3-profiles.csv     # a per-account profile for the writer to use
output/4-hooks.csv        # opening lines, 120 characters max, with a confidence score
output/5-sequences.csv    # the full sequence, ready to push into your sequencer

Every stage is a checkpoint on disk.

You can open any file mid-run, see exactly what the system decided, edit it, and let the next stage pick up your edit. None of it is a black box.

— "One tool runs the stack, not a person"

Hooks: how the stages chain themselves

A hook is a small config file that ties an action to a Claude Code lifecycle event: Stop, PostToolUse, SessionStart, SessionEnd. When that event fires, the hook runs a command. Here is a real one from the repo, the Slack ping that fires whenever a run ends.

// hooks/notifications/slack-ping-on-stop/hook.json
{
  "hooks": {
    "Stop": [
      { "hooks": [
        { "type": "command",
          "command": "bash \"$CLAUDE_GTM_DIR/orchestrator/run.sh\" slack notify" }
      ] }
    ]
  }
}

The pattern is always the same.

On an event, run.sh dispatches to a service and an action, which hands off to a Python handler. The outbound hooks share that exact shape: apollo search to source leads, instantly push to load the campaign, and a Clay-table sync to keep your enrichment sheet current. You never touch this plumbing after install. You feel it as steps that start themselves.

> Every handoff that used to be a person is now just a trigger inside Claude Code.

— "Each step finishing fires the next one"

The five stages, in detail

This is the core of the system, and the part worth reading twice. The /outbound-pipeline command runs these five agents one after another, checking that each output file exists before the next stage begins.

— "The files, and the pipeline they run"

Stage 1: Signal Scraper

Reads your CSV and pulls buying signals out of each company. If the sheet is thin, it does the research for you first: any company missing three or more fields gets sent through web search to fill in industry, headcount, job postings, recent news, tech stack, and funding, and the enriched version is written to 0-enriched.csv so you can see exactly what data it worked from.

It sorts every signal into one of five kinds:

HIRING. New roles, leadership hires, a team that is clearly expanding.
FUNDING. A recent round, IPO prep, or a large investment.
TECHNOLOGY. A stack change, or a new tool going in.
GROWTH. Headcount jumps, new offices, an acquisition.
PAIN. Layoffs, bad press, a pivot, churn at the top.

The output is one row per signal, ranked HIGH to LOW, each with a recommended_angle attached. This stage runs on Haiku by design, because tagging signals across a big list is volume work and the cheap model handles it well.

Stage 2: Lead Prioritizer

This is where the list stops being a pile of names and becomes a ranked queue. Every company gets a score from 1 to 100, built from a fixed rubric worth exactly 100 points across three buckets.

ICP Fit, 40 points. Industry relevance (15), company size against your sweet spot (15), and tech-stack alignment (10).
Signal Strength, 35 points. How recent and specific the signals are (15), how many different signal types showed up (10), and the HIGH/MEDIUM/LOW rating carried over from Stage 1 (10).
Engagement Potential, 25 points. LinkedIn activity level (10), content engagement such as posting and commenting (8), and approachability, meaning how openly they deal with vendors (7).

Those scores roll up into four tiers, and each tier tells the rep what to actually do:

TIER_1   80-100   work today
TIER_2   60-79    work this week
TIER_3   40-59    nurture, wait for a stronger signal
TIER_4   0-39     deprioritize for now

One rule keeps the ranking honest.

When a category has no data behind it, that category is capped at half its points, so a company with no visible LinkedIn footprint can earn at most 12 of 25 on engagement instead of coasting on a guess. Every company comes out with its priority_score, its tier, the three sub-scores, and a one or two sentence scoring_reasoning. That last column is the one to read, because it tells you how the number was reached and gives you something to disagree with. This agent runs on Sonnet, where the extra reasoning pays for itself.

> A 62 with its reasoning attached tells you more than a green dot ever will. You can trace how it got there, and you can overrule it.

Stage 3: Prospect Profiler

Turns each ranked company into a brief a rep could read in about a minute and write from. For every account it produces:

A profile_summary in 100 words or fewer: who they are, what is happening for them right now, and why this is a reasonable moment to reach out.
Three to five key_talking_points, each tied to a specific signal, never a generic industry line.
A communication_style of formal, casual, or technical, read from the industry, the company size, and the contact's title.
The likely potential_pain_points, inferred from the signals rather than assumed.
A recommended_approach written as channel | message_type | timing, for example linkedin | social-proof | this week.
A data_quality flag of HIGH, MEDIUM, or LOW, so you know how far to trust the profile before you lean on it.

It puts its effort where the money is, giving TIER_1 and TIER_2 accounts the deepest analysis and keeping the lower tiers short but still complete. This one also runs on Sonnet.

Stage 4: Hook Writer

Writes the first line of the cold email, and only the first line, because that line is the whole job of getting a second one read. Each opener is capped at 120 characters and labelled by type:

SIGNAL. Anchored to a specific, verifiable event.
INSIGHT. Connects an industry shift to their situation.
PATTERN. References what companies like them tend to do.
CHALLENGE. Asks a pointed question about a pain they probably feel.

Every line ships with a confidence_score and a review_flag, which is what lets you spend your review minutes only on the shaky ones. It also throws out the openers that give a template away. These four are banned outright:

"I saw..."          "Congrats on..."
"I noticed..."      "Hope you're well..."

When the strongest angle it can find is still weak, it flags the line for you instead of polishing a bad idea. This stage runs on Sonnet, since a good first line is judgment, not filler.

Stage 5: Sequence Builder

Wraps each opener in a 7-touch sequence spread across 21 days, with a different angle at every step so no message repeats the one before it. It merges three inputs, the openers from Stage 4, the profiles from Stage 3, and your product config, then writes the finished campaign to 5-sequences.csv, ready for the instantly push hook to send. It drops back to Haiku here, because the structure is already decided and the model is filling a known shape.

Configure it for your product

The pipeline is only as sharp as the config behind it.

One file, input/icp-config.csv, is what separates output that fits what you sell from output that reads like anyone's.

field,value
product_name,...
product_description,"One sentence on what you sell and who it's for"
target_industries,"SaaS, Fintech, Healthcare Tech"
target_company_size_min,50
target_company_size_max,500
key_value_props,"Prop 1|Prop 2|Prop 3"
common_objections,"We already have this|Too expensive|Not a priority"
case_studies,"Customer A: result|Customer B: result"
sender_name,...
sender_title,...
sender_company,...

Put real values in and two things change.

The scorer swaps its default 50-to-500 size band for yours, and the writer starts pulling from your key_value_props and case_studies when it builds PATTERN and INSIGHT lines. Leave the placeholders and the whole thing runs in generic mode. Spend fifteen minutes on this file before your first real run.

Install it in one command

You do not write any code. Clone, install, add one key.

git clone https://github.com/janskuba/go-to-market-orchestrator.git
cd go-to-market-orchestrator
./scripts/install.sh

install.sh does four things in a single pass: it creates your .env from the template and exports CLAUDE_GTM_DIR, copies the skills into ~/.claude/skills/, copies the agents and slash commands into ~/.claude/, and merges every hook.jsoninto ~/.claude/settings.json after taking a timestamped backup of it.

You can install in parts when you want to:

./scripts/install.sh --hooks-only
./scripts/install.sh --hooks=slack-ping-on-stop,instantly-push-campaign   # cherry-pick

Add your keys to .env. The only one required to watch it work is SLACK_WEBHOOK_URL , which you grab from your Slack workspace under Apps → Incoming Webhooks.

# .env
SLACK_WEBHOOK_URL=...
DATA_API_KEY=...
INSTANTLY_API_KEY=...
DRY_RUN=1          # print what each hook WOULD send, without sending it

Then validate before anything can touch a real inbox. validate.sh checks every hook against the Claude Code schema, compiles every handler, runs each one in dry-run, and reports which integrations are live.

./scripts/validate.sh

Leave DRY_RUN=1 on until you have watched a full run print its actions and you believe them. Then take it out.

Run the whole loop

Open Claude Code, point the command at your company CSV, and let it go.

/outbound-pipeline path/to/companies.csv

You can also describe the outcome in plain English, or dictate it with a voice tool if typing slows you down.

Source 100 heads of sales, score them against my ICP,
write the openers, and load the campaign into Instantly.

One stop is built in on purpose.

After Stage 1 enriches a sparse sheet, the pipeline pauses and shows you the researched data before it spends any scoring on it, so a wrong guess gets caught before it spreads through the next four stages. Everything else runs through without a prompt.

— "From a sentence to a loaded campaign"

A few minutes later the list is built, the scorer has kept the leads that clear your bar, the openers are written and flagged, and the campaign is sitting in your sequencer. You did not touch a single tool, and nothing moved between them by hand.

What this actually buys back

It helps to see the bill the manual version quietly runs up. One rep building five lists a week moves each list through roughly eight handoffs: pull, clean, enrich, paste to CRM, write, fix, load, launch. Around 40 minutes of hand-work per list.

— "Eight handoffs, and you are the glue"

Five lists a week puts one rep past three hours of pure data-shuffling. Across a 20-person team that clears 65 hours a week, which is two full-time salaries a year spent carrying records between tabs.

— "What being the glue costs a team"

> The real shift is putting one tool in charge of all the others so the glue stops being a human.

The hooks are what turn those 65 hours into a process that runs in the background while your team sells.

Make it a weekly rhythm

Once a single run works, put it on a clock. The pipeline is a terminal command, so a cron job or any scheduler can launch it on Monday morning and have the lists scored and loaded before you sit down. A SessionStart hook already ships to preload your skills the moment a session opens, so nothing has to be reloaded by hand.

The logging hooks keep the system accountable while it runs.

daily-digest-slack posts a run summary to your channel, local-markdown-transcript saves a written record of every session, and cost-tracker-notion logs what each run cost.

All of it comes from a library of 30 hooks across eight categories: outbound, CRM (HubSpot, Attio, Airtable), notifications, logging, content, and webhooks into Make, n8n, and Zapier. Most switch on the moment their API key lands in .env.

Where to start

Clone the repo, run install.sh, fill in icp-config.csv with your real product and ICP, then run /outbound-pipelineon a list of 20 companies you already understand. Read the five output files in order, top to bottom. That one pass shows you every decision the system made and exactly where to tune it.

From there it compounds.

The hours your team used to burn being the glue quietly go away, and the work still gets done in the background while they actually sell. That one change is what puts a team ahead of the ones still bouncing between ten open tabs all day.

If you would rather rent this than build it, that is what we do at Frontal. We build the full revenue engine behind sales, marketing, and revops. We have done it for 300+ B2B companies, including one we took to $7.83M in qualified pipeline in 10 months without a single SDR hire. You can book a call with us here.

Either way, do one thing this week. Clone the repo and run it once. That first loop is the one that changes how you see outbound for good.