# How to Run Your Entire Outbound From One Claude Code Command
**作者**: Alex Vacca
**日期**: 2026-07-23T17:29:12.000Z
**来源**: [https://x.com/itsalexvacca/status/2080344492415320253](https://x.com/itsalexvacca/status/2080344492415320253)
---
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.
## 相关链接
- [Alex Vacca](https://x.com/itsalexvacca)
- [@itsalexvacca](https://x.com/itsalexvacca)
- [3.7K](https://x.com/itsalexvacca/status/2080344492415320253/analytics)
- [run.sh](https://run.sh/)
- [install.sh](https://install.sh/)
- [validate.sh](https://validate.sh/)
- [install.sh](https://install.sh/)
- [book a call with us here](https://frontal.so/?utm_source=x&utm_medium=article&utm_campaign=claude-code-outbound)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [1:29 AM · Jul 24, 2026](https://x.com/itsalexvacca/status/2080344492415320253)
- [3,725 Views](https://x.com/itsalexvacca/status/2080344492415320253/analytics)
---
*导出时间: 2026/7/24 11:22:38*
---
## 中文翻译
# 如何通过一条 Claude Code 命令运行整个外呼流程
**作者**: Alex Vacca
**日期**: 2026-07-23T17:29:12.000Z
**来源**: [https://x.com/itsalexvacca/status/2080344492415320253](https://x.com/itsalexvacca/status/2080344492415320253)
---
一个 Claude Code 终端就能端到端地运行你的整个外呼闭环。它会拉取公司列表，根据你的 ICP（理想客户画像）对每一条线索进行评分，为每个账户建档，撰写个性化开场白，构建触达序列，并将其推送到你的序列发送工具中。一条命令就能搞定所有这一切。
其核心机制是“钩子（hooks）”。
当一个阶段完成时，钩子会自动触发下一个阶段，因此不需要你等待导出文件或切换标签页。以下是完整的构建内容：代码仓库、组成管道的五个代理、它们运行的 1 到 100 分评分标准，以及将它们串联起来的钩子。克隆它，填入你的密钥，当天下午就可以在真实的列表上运行了。
我曾为 275 多家 B2B 公司构建过上市（GTM）系统。下面是具体的设置步骤，而非产品推销。
# 该流程产出了什么
你只需将管道指向一个 CSV 文件，该文件至少需要包含一列公司名称。从那里开始，它会按顺序运行五个代理，每个代理都会将其输出写入一个文件，供下一个代理读取。
```
output/0-enriched.csv # 网络调研字段，仅在你的输入信息较少时生成
output/1-signals.csv # 每家公司的购买信号，按 HIGH → LOW 排序
output/2-prioritized.csv # 1-100 的评分、分层及其背后的原因
output/3-profiles.csv # 供撰写者使用的单账户档案
output/4-hooks.csv # 开场白，最多 120 个字符，并附带置信度评分
output/5-sequences.csv # 完整的触达序列，准备好推送到你的序列发送工具
```
每个阶段都是磁盘上的一个检查点。
你可以在运行中途打开任何文件，查看系统具体做出了什么决定，对其进行编辑，然后让下一个阶段接手你的编辑结果。这一切都不是黑盒。
一个工具运行整个技术栈，而不是一个人
# 钩子：各阶段如何自动串联
钩子是一个小型配置文件，它将操作绑定到 Claude Code 的生命周期事件：Stop（停止）、PostToolUse（工具使用后）、SessionStart（会话开始）、SessionEnd（会话结束）。当该事件触发时，钩子会运行一条命令。以下是仓库中的一个真实示例，即每次运行结束时触发的 Slack 通知。
```
// hooks/notifications/slack-ping-on-stop/hook.json
{
"hooks": {
"Stop": [
{ "hooks": [
{ "type": "command",
"command": "bash \"$CLAUDE_GTM_DIR/orchestrator/run.sh\" slack notify" }
] }
]
}
}
```
模式始终如一。
当事件触发时，run.sh 分发给一个服务和操作，再交给 Python 处理器处理。外呼钩子共享这种确切的结构：apollo search 用于获取线索，instantly push 用于加载营销活动，以及 Clay-table sync 用于保持你的信息补全表格是最新的。安装后你无需再触碰这些底层逻辑。你感知到的就是那些自动启动的步骤。
> 过去每一次由人工完成的交接，现在都只是 Claude Code 内部的一个触发器。
每一步完成后触发下一步
# 五个阶段的详细解析
这是系统的核心，值得读两遍。/outbound-pipeline 命令会接连运行这五个代理，并在下一阶段开始前检查上一个输出文件是否存在。
文件及其运行的管道
## 阶段 1：信号抓取器
读取你的 CSV 并从每家公司中提取购买信号。如果表格信息单薄，它会先帮你进行研究：任何缺少三个或更多字段的公司都会被送往网络搜索，以填补行业、员工人数、招聘信息、最新新闻、技术栈和资金情况，并将丰富后的版本写入 0-enriched.csv，这样你就能确切知道它基于什么数据工作。
它将每个信号分为五种之一：
- HIRING（招聘）。新职位、领导层招聘、明显扩张的团队。
- FUNDING（融资）。近期融资轮、IPO 准备或大额投资。
- TECHNOLOGY（技术）。技术栈变更，或引入新工具。
- GROWTH（增长）。员工人数激增、新办公室、收购。
- PAIN（痛点）。裁员、负面新闻、转型、高层流失。
输出是每个信号一行，按 HIGH 到 LOW 排序，每个信号都附有一个 recommended_angle（推荐角度）。该阶段设计为在 Haiku 上运行，因为为大量列表标记信号属于批量工作，便宜的模型能很好地处理。
## 阶段 2：线索优先级排序器
在这里，列表不再是一堆名字，而变成了一个排名队列。每家公司都会获得一个 1 到 100 的分数，该分数基于一个固定的评分标准，该标准在三个维度总分正好 100 分。
- ICP Fit（理想客户匹配度），40 分。行业相关性（15 分）、公司规模与你的最佳区间的匹配度（15 分）以及技术栈对齐度（10 分）。
- Signal Strength（信号强度），35 分。信号的时效性和具体程度（15 分）、出现的不同信号类型的数量（10 分），以及从阶段 1 继承而来的 HIGH/MEDIUM/LOW 评级（10 分）。
- Engagement Potential（互动潜力），25 分。LinkedIn 活跃度（10 分）、内容互动如发帖和评论（8 分），以及 approachability（可接近度），即他们公开对待供应商的程度（7 分）。
这些分数汇总为四个层级，每个层级告诉销售实际该做什么：
```
TIER_1 80-100 今天处理
TIER_2 60-79 本周处理
TIER_3 40-59 培育，等待更强的信号
TIER_4 0-39 暂时降级处理
```
有一条规则能保证排名的真实性。
当某个类别没有数据支持时，该类别的得分上限减半，因此一家没有可见 LinkedIn 足迹的公司在互动潜力上最多只能得 25 分中的 12 分，而不是靠猜测蒙混过关。每家公司都会生成 priority_score（优先级分数）、tier（层级）、三个子分数，以及一两句的 scoring_reasoning（评分理由）。最后一列最值得一读，因为它告诉你分数是如何得出的，并给你一个可以反驳的依据。该代理在 Sonnet 上运行，额外的推理能力是值得的。
> 一个带有理由的 62 分，比一个绿点告诉你的要多得多。你可以追踪它是如何得出的，也可以推翻它。
## 阶段 3：潜在客户档案生成器
将每家排名靠前的公司转变为一份销售可以在一分钟左右读完并据此撰写的简报。对于每个账户，它会生成：
- profile_summary（档案摘要），100 字以内：他们是谁，他们目前发生了什么，以及为什么此时联系是合理的。
- 三到五个 key_talking_points（关键谈话要点），每一个都与特定信号挂钩，绝不是通用的行业套话。
- communication_style（沟通风格），分为 formal（正式）、casual（随意）或 technical（技术），根据行业、公司规模和联系人头衔读取。
- 可能的 potential_pain_points（潜在痛点），是从信号中推断出来的，而不是假设的。
- recommended_approach（推荐方法），以 channel | message_type | timing（渠道 | 消息类型 | 时机）的形式编写，例如 linkedin | social-proof | 本周。
- data_quality（数据质量）标记，为 HIGH、MEDIUM 或 LOW，这样你在依赖它之前就知道该信任到什么程度。
它把精力花在能产生效益的地方，给予 TIER_1 和 TIER_2 账户最深度的分析，并保持低层级简短但完整。该阶段同样在 Sonnet 上运行。
## 阶段 4：钩子撰写器
撰写冷邮件的第一行，而且只写第一行，因为这一行是让人愿意读第二行的全部工作。每段开场白最多 120 个字符，并按类型标记：
- SIGNAL（信号）。锚定在一个具体的、可验证的事件上。
- INSIGHT（洞察）。将行业转变与他们的情况联系起来。
- PATTERN（模式）。参考像他们这样的公司通常会做的事情。
- CHALLENGE（挑战）。针对他们可能感受到的痛点提出一个尖锐的问题。
每一行都附带 confidence_score（置信度分数）和 review_flag（审查标记），这让你可以只把审查时间花在那些不确定的开场白上。它还会丢弃那些暴露模板痕迹的开场白。这四种被直接禁止：
```
"I saw..." "Congrats on..."
"I noticed..." "Hope you're well..."
```
当它能找到的最强角度依然很弱时，它会为你标记该行，而不是去修饰一个糟糕的想法。该阶段在 Sonnet 上运行，因为好的第一行是判断力的体现，而不是填充物。
## 阶段 5：序列构建器
将每段开场白包裹在一个跨度 21 天、包含 7 次触达的序列中，每一步都采用不同的角度，因此没有一条消息会与前一条重复。它合并三个输入：来自阶段 4 的开场白、来自阶段 3 的档案以及你的产品配置，然后将完成的营销活动写入 5-sequences.csv，准备好由 instant push 钩子发送。这里回退到 Haiku，因为结构已经确定，模型只是在填充一个已知的框架。
# 为你的产品进行配置
管道的犀利程度取决于背后的配置。
一个文件，input/icp-config.csv，是区分符合你销售的产品与通用输出的关键。
```
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,...
```
填入真实值后，会发生两件事。
评分器会将默认的 50 到 500 人的规模区间替换为你的区间，而撰写者在构建 PATTERN 和 INSIGHT 类型的开场白时，会开始从你的 key_value_props 和 case_studies 中提取素材。如果保留占位符，整个系统将以通用模式运行。在第一次正式运行前，请花十五分钟在这个文件上。
# 一条命令完成安装
你不需要编写任何代码。克隆、安装、添加一个密钥。
```
git clone https://github.com/janskuba/go-to-market-orchestrator.git
cd go-to-market-orchestrator
./scripts/install.sh
```
install.sh 一次性完成四件事：它根据模板创建你的 .env 并导出 CLAUDE_GTM_DIR，将技能复制到 ~/.claude/skills/，将代理和斜杠命令复制到 ~/.claude/，并在对 ~/.claude/settings.json 进行带时间戳备份后，将每个 hook.json 合并到其中。
如果需要，你也可以分步安装：
```
./scripts/install.sh --hooks-only
./scripts/install.sh --hooks=slack-ping-on-stop,instantly-push-campaign # 挑选安装
```
将你的密钥添加到 .env 中。唯一必需的密钥是 SLACK_WEBHOOK_URL，你可以从 Slack 工作区的 Apps → Incoming Webhooks 中获取。
```
# .env
SLACK_WEBHOOK_URL=...
DATA_API_KEY=...
INSTANTLY_API_KEY=...
DRY_RUN=1 # 打印每个钩子将要发送的内容，但不实际发送
```
然后在任何操作触及真实收件箱之前进行验证。validate.sh 会根据 Claude Code 架构检查每个钩子，编译每个处理器，在试运行模式下运行每一个，并报告哪些集成已激活。
```
./scripts/validate.sh
```
保留 DRY_RUN=1，直到你观察完一次完整运行打印出的操作并确信它们无误。然后再关闭它。
# 运行整个闭环
打开 Claude Code，将命令指向你的公司 CSV，然后让它运行。
```
/outbound-pipeline path/to/companies.csv
```
你也可以用简单的英语描述想要的结果，或者如果打字太慢，可以使用语音工具口述。
```
Source 100 heads of sales, score them against my ICP,
write the openers, and load the campaign into Instantly.
```
特意设置了一个暂停点。
在阶段 1 丰富信息单薄的表格后，管道会暂停并向你展示调研数据，然后再进行任何评分，这样错误的猜测就能在扩散到接下来的四个阶段之前被发现。其他所有步骤都会顺畅运行，无需提示。
从一句话到加载完成的营销活动
几分钟后，列表构建完成，评分器保留了符合你标准的线索，开场白已撰写并标记，营销活动已放置在你的序列发送工具中。你没有触碰任何工具，也没有任何数据在工具间手动移动。
# 这实际上为你节省了什么
看一看手动操作悄悄累积的成本会有所帮助。一个销售每周构建五个列表，每个列表大约要经过八次交接：拉取、清洗、丰富、粘贴到 CRM、撰写、修正、加载、启动。每个列表大约需要 40 分钟的人工工作。
八次交接，而你是胶水
每周五个列表，会让一个销售每周花费超过三小时纯粹的数据搬运。对于一个 20 人的团队来说，每周就是 65 小时，也就是每年两名全职员工的薪水花在了标签页之间搬运记录上。
作为“胶水”对团队的代价
> 真正的转变是让一个工具负责管理所有其他工具，这样胶水就不再是人了。
钩子正是将这 65 小时转化为一个在后台运行的流程的东西，而此时你的团队正在销售。
# 将其变成每周的节奏
一旦单次运行成功，就把它设定为定时任务。管道是一个终端命令，因此 cron 作业或任何调度程序都可以在周一早上启动它，并在你坐下之前完成列表的评分和加载。SessionStart 钩子已经内置，可以在会话打开时预加载你的技能，因此无需手动重新加载任何内容。
日志钩子在系统运行时保持其可追溯性。
daily-digest-slack 将运行摘要发布到你的频道，local-markdown-transcript 保存每个会话的书面记录，cost-tracker-notion 记录每次运行的成本。
所有这些都来自一个包含 8 个类别共 30 个钩子的库：外呼、CRM（HubSpot, Attio, Airtable）、通知、日志、内容，以及连接到 Make、n8n 和 Zapier 的 Webhook。大多数只要其 API 密钥落入 .env 文件就会立即启用。
# 从哪里开始
克隆仓库，运行 install.sh，用你的真实产品和 ICP 填写 icp-config.csv，然后在一个你已经了解的 20 家公司的列表上运行 /outbound-pipeline。按顺序，从上到下阅读五个输出文件。这一遍遍历会向你展示系统做出的每一个决定，以及确切可以在哪里进行微调。
从那里开始，它会不断产生复利。
你的团队过去作为“胶水”消耗的悄然消失了，工作仍然在后台完成，而他们可以真正地去销售。这一个改变就是让团队领先于那些整天在十个打开的标签页之间跳来跳去的团队的关键。
如果你宁愿租用这个系统而不是自己构建，这正是我们在 Frontal 所做的。我们为销售、市场和运营构建完整的收入引擎。我们已经为 300 多家 B2B 公司做到了这一点，包括一家我们在 10 个月内帮助其产生了 783 万美元合格管道且未聘请任何 SDR 的公司。你可以在这里预订与我们通话。
无论哪种方式，本周做一件事。克隆仓库并运行一次。第一个闭环将永远改变你对对外销售的看法。
## 相关链接
- [Alex Vacca](https://x.com/itsalexvacca)
- [@itsalexvacca](https://x.com/itsalexvacca)
- [3.7K](https://x.com/itsalexvacca/status/2080344492415320253/analytics)
- [run.sh](https://run.sh/)
- [install.sh](https://install.sh/)
- [validate.sh](https://validate.sh/)
- [install.sh](https://install.sh/)
- [book a call with us here](https://frontal.so/?utm_source=x&utm_medium=article&utm_campaign=claude-code-outbound)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [1:29 AM · Jul 24, 2026](https://x.com/itsalexvacca/status/2080344492415320253)
- [3,725 Views](https://x.com/itsalexvacca/status/2080344492415320253/analytics)
---
*导出时间: 2026/7/24 11:22:38*