10 Claude Code Automations for GTM, With Setup Steps

A practical setup guide. Each workflow includes what it is, what it solves, what you need, the setup steps, what to expect, and a bonus tip where there's a real one worth giving.

These are not theoretical. Every workflow here is from operators running this exact setup at scale.

---

01Workflow 1: Email Finding Waterfall with Caching

What it is

A 3-tier email finding system that runs cheap permutation guessing first, then a verified paid provider for catch-all domains, then a sender-data validator at the end. Every found email caches in a database with a date stamp so you never pay to find the same email twice.

What it helps with

Cuts email finding costs dramatically when you scale past a few thousand contacts a month. Operators report finding 50-70% of emails at near-zero cost through permutation guessing, with the paid layers handling only the harder cases. Caching saves you from paying for the same contact twice across campaigns.

What you need

• Claude Code subscription
• Million Verifier API key (real-time email verification)
• Prospeo API key (paid email finding with built-in catch-all verification)
• Smartlead API key (final-layer validation against actual sending data)
• Supabase account (for the email cache database)
• Trigger.dev account (for scheduled runs)

Setup steps

1. Set up your folder structure. Inside Claude Code, create a project folder for this system. Add a CLAUDE.md file at the root with directions on how the waterfall works (which provider runs first, second, third). Create a .env file for your API keys. Never paste keys into chat.
2. Scrape the API docs into a skill. Point Claude Code at each provider's API documentation page (Million Verifier, Prospeo, Smartlead). Have it read the docs and save each one as a skill file inside your library folder. This means Claude does not re-research the docs on every run.
3. Build the Supabase cache table. Create a Supabase project. Add a table for cached emails with columns for LinkedIn URL slug, email, validation date, source provider, and validation status. Have Claude Code generate the schema for you.
4. Write the waterfall logic. Prompt Claude Code: "Build a script that takes a CSV of first names, last names, and company domains. For each contact, first check the Supabase cache. If found and validated less than 90 days ago, reuse it. If not, generate the 10 most common email permutations and validate each with Million Verifier, accepting only status 'okay' (no catch-all, no invalid). If no valid email is found, call Prospeo. If still no email, call Smartlead. Cache every found email to Supabase."
5. Deploy as a scheduled task. Set up Trigger.dev to run the script on a cron schedule. Most operators run this hourly during off-peak hours (2am works well, since the API providers are less rate-limited).

What to expect

For 1,000 contacts, expect to find emails for roughly 600-700 of them. Of those, around 50-70% will come from the cheap permutation layer, which costs almost nothing. The remaining 30-50% gets handled by the paid providers, which is where the bulk of your cost lives. Catch-all domains will always be the trickiest layer, which is why Prospeo sits in the middle of the waterfall (it has built-in catch-all handling).

---

02Workflow 2: Deterministic Tier Scoring with Python

What it is

A scoring system that takes your company list and tiers each company into T1, T2, T3, or Disqualified using Python rules instead of AI prompts. Because the maths is deterministic, there's zero room for hallucination on numerical fields like company size or revenue.

What it helps with

Most teams either skip scoring (and waste outreach on companies that won't convert) or use AI for it (and get hallucinations at scale where a 50-employee company gets tiered as enterprise). Deterministic scoring fixes both. It also makes tier-to-channel routing possible, where T1 companies get human SDR outreach, T2 gets multi-channel sequencing, and T3 gets automated nurture.

What you need

• Claude Code subscription
• Your company list as a CSV (with columns for employee count, revenue, funding, industry, and any other fields you score on)
• Closed-won and closed-lost CRM data (to build the scoring criteria from real conversion patterns)

Setup steps

1. Set up your folder structure. Create a project folder for this scoring system. Inside, create three files: a CLAUDE.md (with directions), a scoring-criteria.md (where the actual tier rules live), and a tier-actions.md (which tier maps to which outreach approach).
2. Build the scoring criteria from your CRM. Export your closed-won and closed-lost lists. Prompt Claude Code: "Look at the closed-won contacts versus the closed-lost contacts. Tell me what employee size range, revenue range, industry pattern, and tech stack pattern is most predictive of a closed-won deal." Use the answer as the basis for your tier rules. Tier 1 should match your closed-won pattern most closely.
3. Write the criteria into scoring-criteria.md. Format it as clear conditional rules. For example: "If employees between 100 and 500 AND revenue greater than $5M AND industry is software, score Tier 1. If employees between 50 and 100 AND industry is software, score Tier 2. If industry is not software, mark Disqualified."
4. Drop in your company list. Copy your company list CSV. In Claude Code, prompt: "Tier this company list using my scoring criteria." Claude Code will read both files and generate a Python script that scores each company deterministically. The output is a CSV with each company tagged with its tier.
5. Map tiers to outreach approach. In your tier-actions.md, write what happens to each tier. T1 routes to human SDR or AE. T2 goes to multi-channel email and LinkedIn sequencing. T3 goes to automated email nurture. DQ is excluded.

What to expect

Scoring 1,000 companies takes under a minute. Scoring 10,000 takes a few minutes. The output is reliable because Python doesn't hallucinate on numbers. Your tier distribution will tell you something useful: if 80% of companies are landing in T3, your criteria is too loose. If 95% are landing in DQ, your criteria is too strict. Iterate the criteria until you have a workable mix.

---

03Workflow 3: LinkedIn Ad Campaign from a Google Sheet

What it is

A spreadsheet-driven LinkedIn ad campaign builder. You define each campaign as a row in a Google Sheet (campaign group, name, targeting type, ad copy reference, creative folder), and Claude Code reads the sheet, hits the LinkedIn Ads API, and creates the campaigns at scale.

What it helps with

LinkedIn's native UI is one of the slowest places in advertising to do bulk work. Updating bidding across 30 campaigns, swapping account lists, or launching a new ABM campaign with reused targeting all take painful clicks. This workflow turns those tasks into a sheet edit. The same approach extends to Meta Ads and Google Ads.

What you need

• Claude Code subscription
• LinkedIn Marketing Developer Platform access (this requires application approval, see step 1)
• Google Sheets API access via a Google Cloud project with a service account
• Google Drive folder for ad creative (images and videos)
• A LinkedIn Ad Account where you have admin role

Heads up: everything waits on LinkedIn approval. LinkedIn Marketing Developer Platform access requires application approval and can take days to weeks. Apply first, then build the rest of the workflow while you wait.

Setup steps

1. Apply for LinkedIn Ads API access first. Everything else waits on this. Create an app at developer.linkedin.com, add the Advertising API product, and complete the access form under My Apps. LinkedIn reviews each application against their supported use cases. Approval can take days to weeks. Development tier (read-only for unlimited accounts, edit for up to 5) is enough for most agencies. Standard tier is needed only for managing many accounts at scale.
2. Set up Google Sheets API access. Create a Google Cloud project. Enable the Google Sheets API and the Google Drive API. Create a service account, download the JSON key, and share your campaign sheet with the service account email (with edit access).
3. Build your campaign sheet schema. Create a Google Sheet with columns for campaign group, campaign name, targeting type (such as bottom-of-funnel or ABM), saved audience reference, ad copy text, and a Drive folder link for the creative assets. Each row equals one campaign.
4. Set up the Claude Code project. Create a folder with a CLAUDE.md (directions on how the workflow operates), a .env file for the LinkedIn and Google API credentials, and a skills subfolder for the API documentation.
5. Use plan mode to wire up the API. Open Claude Code in plan mode and prompt: "Help me set up the LinkedIn Ads API to create a campaign programmatically. Walk me through the API call structure, then test it with one campaign before saving as a skill." Claude Code will run trial-and-error against the API until campaign creation works, then save the working pattern as a skill via a checkpoint command so the script is reusable.
6. Connect the sheet to the API call. Prompt: "Read the Google Sheet at this URL. For each row, create a LinkedIn ad campaign using the saved skill. Pull creative from the Drive folder reference. Use the saved audience for targeting. Output a summary of created campaigns." Verify against the LinkedIn Campaign Manager UI.
7. Repeat for Meta and Google Ads. Same pattern. Different APIs. Different sheet schemas. The Meta and Google Ads APIs both have MCP servers available, which reduces setup time compared to LinkedIn (which requires direct API calls).

What to expect

After the LinkedIn API approval and the initial setup, creating a new campaign takes about as long as filling in a sheet row. Bulk updates (changing bidding across 30 campaigns, swapping account lists for ABM campaigns, refreshing creative) are where this workflow really pays off. Setup is heavier than most workflows in this guide because of the LinkedIn approval step. Once over that hurdle, the time savings compound across every campaign.

---

04Workflow 4: Multi-Channel Campaign Launch in One Prompt

What it is

A single Claude Code prompt that takes a qualified contact list plus copy plus campaign context, then creates the email campaign in Instantly, configures the deliverability settings, pushes the leads, and optionally triggers a parallel LinkedIn campaign in HeyReach for the same contacts.

What it helps with

The end-to-end campaign launch is the single most copy-paste-heavy job in outbound. Pull leads from one tool, paste into another, log into the sequencer, create the campaign, paste copy, paste leads, set deliverability options, hit send. This workflow collapses all of that into one prompt that takes under a minute to execute. Adding LinkedIn parallels makes it multi-channel out of the box.

What you need

• Claude Code subscription
• Instantly account with API access (V2 API requires a workspace on the Hypergrowth plan or above)
• Instantly API key (Bearer token, generated from Settings > Integrations)
• HeyReach account with API access (optional, for the LinkedIn layer)
• HeyReach API key (Integrations > HeyReach API > Get API Key)
• Your contact list (already enriched with verified emails)
• Your copy framework MD file (see bonus tip below)

Setup steps

1. Set up the Claude Code folder. Create a CLAUDE.md with directions. Create a .env file for both API keys. Create a copy-frameworks.md with your best-performing past email templates organised by campaign type (event, offer, signal, problem-led).
2. Scrape and save the API docs as skills. Point Claude Code at the Instantly V2 API docs (developer.instantly.ai) and the HeyReach API docs. Have it read both and save each as a skill in your library folder. The relevant Instantly endpoints are POST /api/v2/campaigns (create), POST /api/v2/leads (bulk add), and the campaign settings endpoints.
3. Drop in your contact list. Save your enriched contact CSV in the project folder.
4. Run the campaign creation prompt. A working prompt looks like: "Create an Instantly campaign called [name]. Pull the best-performing copy framework from copy-frameworks.md that matches this campaign type: [event / offer / signal / problem-led]. Inject this campaign context: [date, offer, key points]. Configure plain text only on the first email, 10-minute send gap, provider matching enabled, 100 daily limit. Push all leads from contacts.csv. Leave the campaign in draft so I can preview before launching."
5. Verify before launching. Open Instantly. Confirm the leads loaded, the copy looks right, the personalisation tokens are mapped correctly, the schedule is correct. Hit resume to launch, or prompt Claude Code to launch it for you.
6. Add the LinkedIn parallel (optional). Prompt: "For the same contacts, create a HeyReach campaign called [name]. Use a 'Find Email' branch logic: if the lead has a verified email, route them to the Instantly campaign. If not, run them through a LinkedIn-only sequence." This branching is built into HeyReach natively.

What to expect

End-to-end campaign creation in under 90 seconds, including lead push and deliverability configuration. The first campaign you set up will take longer because you're saving the API docs as skills. Every campaign after that runs at full speed. The biggest gotcha is making sure your copy frameworks file actually has copy frameworks in it (not vague guidelines), because Claude Code injects the framework directly into the campaign.

---

05Workflow 5: LinkedIn Engagement Scraper to Outbound Trigger

What it is

You drop in a LinkedIn post URL. Claude Code scrapes the post's engagers (likes, comments, shares), pushes them to a Clay table where each engager gets ICP-qualified and enriched, and routes the qualified ones to an outbound sequencer or a Slack channel for SDR follow-up.

What it helps with

People who engage with content related to your space have already raised their hand. Reaching out to them is one of the highest-converting outbound plays available. The manual version of this (checking likes, opening profiles, finding emails, reaching out) is unsustainable past a few posts. This workflow turns engagement into a pipeline trigger that runs weekly without any manual effort, and operators report it replacing dedicated tools that cost $300+ per month.

What you need

• Claude Code subscription
• Apify account and API token (for the LinkedIn engagement scraper)
• Clay account (for ICP qualification, enrichment, and routing)
• A target LinkedIn post URL (yours, a competitor's, or a thought leader in your space)
• An outbound sequencer (Instantly, Smartlead, or lemlist) OR a Slack workspace for SDR routing
• Optional: Railway account if you want this running automatically on a schedule

Setup steps

1. Pick your scraper actor on Apify. Apify has multiple LinkedIn engagement scrapers. The "no cookies" actors are the safer choice because they don't require you to share your LinkedIn login. For full coverage you'll want one that handles likes, comments, and reactions on a post (these actions get scraped via separate endpoints in some actors, so check what each one returns before settling). Get your Apify API token from the Integrations section of your Apify Console.
2. Set up the Clay receiving table. In Clay, click + Add at the bottom of a workbook, search for Webhooks, click Monitor webhook. Copy the unique webhook URL. This is where Claude Code will push the engagers. Optionally add an authentication token in the header for security.
3. Build the qualification logic in Clay. In the same table, add columns for ICP enrichment (job title, company size, industry), block list checks (against your CRM, partners, customers), and ICP scoring. Add a final routing column that decides between outbound sequencer, SDR Slack channel, or skip.
4. Set up the Claude Code project. Create a folder with a CLAUDE.md (directions on the workflow), a .env file for the Apify API token and the Clay webhook URL, and the Apify actor's API documentation saved as a skill.
5. Run the scraper-to-Clay flow. A working prompt: "Take this LinkedIn post URL [paste]. Run the Apify engagement scraper actor and pull all likers, commenters, and resharers. For each engager, push first name, last name, LinkedIn profile URL, headline, and company to the Clay webhook URL." Claude Code calls Apify, waits for the run to finish, parses the dataset, and POSTs each engager to your Clay webhook. The Clay table updates instantly.
6. Let Clay handle qualification and routing. Clay's enrichment and routing logic runs on its own. Qualified engagers get pushed to your sequencer. SDR-tier engagers get posted to a Slack channel.
7. Optional: deploy as a weekly auto-runner. Wrap the script in a scheduled task and deploy to Railway. Set a cron to run every Monday morning across your team's recent posts. Now this entire pipeline runs without you ever opening Claude Code.

What to expect

A post with 200-300 engagers gets fully scraped, pushed to Clay, qualified, enriched, and routed in 5-15 minutes depending on Apify run times and your Clay enrichment depth. The quality of leads is consistently higher than firmographic outbound because every contact has shown intent on a relevant topic. Watch out for Clay's 50,000-row table limit, you may need to cycle webhook URLs across multiple tables for high-volume teams.

---

06Workflow 6: Self-Syncing Client Playbook

What it is

A per-client playbook that lives in a GitHub repo and stays current automatically. Every week, Claude Code pulls new call transcripts, new campaign results, and new client feedback, then updates the playbook with what changed. Every downstream campaign references the latest version.

What it helps with

Most agencies and in-house teams capture client knowledge in scattered Notion docs, Slack threads, and people's heads. Within three months it's stale. Within six months nobody trusts it. This workflow turns the playbook into a living document that gets sharper every week. New campaigns inherit the latest understanding of the customer instead of starting from a months-old brief.

What you need

• Claude Code subscription
• GitHub account (free tier works) and a private repo per client
• Fireflies account with API access (for pulling call transcripts) OR another transcription tool with an API
• Access to your campaign analytics (Instantly, Smartlead, or wherever campaigns run)
• Per-client onboarding materials, client website URL, and any internal notes from the team

Setup steps

1. Create a GitHub repo per client. Name them consistently (such as "playbook-acme" or "client-acme"). Inside each repo, create a structure like: README.md (summary), 01-icp.md, 02-positioning.md, 03-objections.md, 04-competitors.md, 05-campaign-history.md, and a /transcripts folder for raw call data.
2. Build the initial playbook. Prompt Claude Code: "Read [client website URL] and the materials in /onboarding. Build the first version of the playbook covering ICP, positioning, key pain points, objections, and competitive landscape. Save each section as the corresponding MD file in the repo." This gives you the foundation.
3. Set up the Fireflies API access. In Fireflies, go to Integrations and copy your API key (it's a Bearer token used against the GraphQL endpoint at api.fireflies.ai/graphql). Save it in your Claude Code .env file. Save the Fireflies GraphQL schema as a skill.
4. Build the transcript ingestion script. Prompt Claude Code: "Once a week, query the Fireflies API for new transcripts tagged with [client name]. For each new transcript, save the raw text to /transcripts in the GitHub repo, then extract: new objections, new pain point language, competitive mentions, and decision-maker patterns. Update the relevant playbook MD files with what changed."
5. Add the campaign feedback loop. Prompt Claude Code: "Once a week, pull campaign analytics from Instantly. Identify positive replies and what they engaged with. Identify negative replies and what they pushed back on. Append patterns to 05-campaign-history.md and update the ICP and objections files where the data points to a shift."
6. Add the client feedback layer. Whenever the client gives qualitative feedback (in a weekly call, over Slack, or in writing), drop it into a /feedback folder. Have Claude Code synthesise and route the feedback into the right playbook section during the weekly sync.
7. Schedule the weekly sync. Set up a Trigger.dev or Railway scheduled task that runs the full pipeline every Monday morning. Claude Code commits the updates to the GitHub repo automatically. The team starts the week with a fresh playbook.

What to expect

The first sync takes longest because Claude Code is processing all historical transcripts and campaign data. Subsequent weekly syncs only process the delta and finish in minutes. The playbook becomes the source of truth your team references before any campaign brief, and the quality of the brief improves visibly within four to six weeks of consistent syncing.

---

07Workflow 7: Reply Intelligence Loop

What it is

A weekly job that pulls reply data from your sequencer, categorises every reply by sentiment (positive, negative, neutral, objection), traces winning replies back to the persona, tier, copy, and signal that produced them, then updates your knowledge base and targeting filters so the next campaign starts smarter.

What it helps with

The biggest single difference between operators who scale and operators who plateau is whether their next campaign starts smarter than the last. Most teams have campaign analytics in Instantly or Smartlead and never look at them past the surface metrics. This workflow turns reply data into a structured feedback loop, so winning patterns become next week's targeting filter and losing patterns get pruned automatically.

What you need

• Claude Code subscription
• Instantly or Smartlead account with API access (Instantly V2 API requires Hypergrowth or above; Smartlead has its own API on standard plans)
• Your knowledge base storage (the GitHub repo from Workflow 6 works here, or a Notion database)
• Optionally: Slack workspace for routing positive replies to your team in real time

Setup steps

1. Save the sequencer's API docs as a skill. For Instantly, the relevant endpoints are GET /api/v2/campaigns/analytics (overview metrics), GET /api/v2/campaigns/analytics/daily (day-by-day breakdown), GET /api/v2/emails (individual reply data via the email object). Have Claude Code scrape developer.instantly.ai and save as a skill.
2. Pull historical reply data. First run prompt: "Pull all replies from the last 90 days across all campaigns. For each reply, capture: campaign ID, copy variant used, lead's job title, lead's company size, lead's tier, the original signal that triggered the touch, the reply text, and the timestamp. Save to /reply-data/historical.csv."
3. Build the sentiment classification. Prompt: "For each reply in historical.csv, use a Sonnet sub-agent to classify the sentiment as positive (interested, asking for more info, booking a meeting), negative (not interested, wrong person, competitor), objection (interested but pushing back on something specific), or neutral (auto-reply, OOO, unrelated). Add the classification as a new column. Add a second column for the specific objection or interest signal extracted from the reply text."
4. Trace winners back to source patterns. Prompt: "For all positive replies, identify the most predictive attributes: which job titles, which company sizes, which tiers, which copy variants, which signals. Output the top three winning combinations." This is the persona discovery layer.
5. Update the knowledge base. Prompt: "Append the winning patterns to the knowledge base at /knowledge-base/persona-patterns.md. Append common objections to /knowledge-base/objections.md. Append signal effectiveness to /knowledge-base/signals.md."
6. Wire it to the next campaign's targeting. Before launching any new campaign, prompt: "Read persona-patterns.md. Apply the top winning persona as the targeting filter for this campaign. Pull contacts that match." Now every new campaign launches with the latest learned targeting baked in.
7. Schedule weekly. Set up the full pipeline as a scheduled task on Trigger.dev or Railway. Run every Monday morning. Add a Slack notification when the weekly run completes, with the top 3 patterns surfaced for human review.

What to expect

The first run is the heaviest because Claude Code is processing 90 days of reply data. Subsequent weekly runs only process the new replies, which usually completes in minutes. The compounding effect shows up around weeks 4-8, when you can clearly see the targeting filter has shifted based on real performance data, and reply rates start climbing on the same volume of sends. The most surprising output is usually that your assumed best persona is not actually the best replier in your data.

---

08Workflow 8: Dynamic 4-Layer Block List

What it is

A four-layer block list system that prevents your outbound from hitting current customers, open opportunities, partners, investors, your CEO's network, and anyone who already said no. Layer 1 syncs from your CRM in real time. Layer 2 is your manually curated relationship protection list. Layer 3 auto-suppresses behavioural signals at the company level (not just the contact level). Layer 4 is a Clay enrichment lookup that runs every contact through the block list before it enters any sequence.

What it helps with

The most overlooked part of every outbound campaign setup. Operators who skip this run real risk: hitting your own customers, your investors, your board, and the CEO's network with cold email is recoverable from a bounce-rate perspective and devastating from a relationship perspective. One operator paused 30 campaigns and 100,000+ touches because the block list was stale and qualified leads were reaching contacts the founder had personal relationships with. The cost-per-lead was good. The reputational cost was not.

What you need

• Claude Code subscription (for orchestration)
• HubSpot or Salesforce (CRM source of truth)
• OutboundSync account (for bidirectional sync between CRM and sequencer block lists)
• Instantly or Smartlead account
• Clay account (for the enrichment lookup layer)
• Your manually curated "never touch" list (investors, board, partners, advisors)

Setup steps

1. Layer 1: Connect CRM to sequencer block list via OutboundSync. Install OutboundSync. Generate a webhook in Instantly (Settings > Integrations > Webhooks) and paste the OutboundSync URL. In your CRM, build lists for: current customers, open opportunities, deals in negotiation, churned customers (or whatever segments you never want hit). OutboundSync syncs these lists into your sequencer's block list automatically. Active customer? Suppressed. Deal in negotiation? Suppressed. Partner account? Suppressed. The list updates in real time as deals move stages.
2. Layer 2: Build the manually curated relationship list. Create a separate "never touch" list in your CRM with: investors, board members, advisors, co-sell partners, press contacts, former colleagues of founders and execs. This list barely changes month to month, but it has to exist. Sync it through OutboundSync the same way as Layer 1. Build it before you launch any new outbound campaign.
3. Layer 3: Configure behavioural suppression at the company level. In Instantly or Smartlead, set up rules that auto-add to the block list when a lead replies with "unsubscribe", "not interested", "remove me", or similar. The crucial part most teams miss: suppress at the company domain level, not just the contact level. If someone at Acme Corp says no, the entire acme.com domain gets suppressed for 90 days minimum. Both Instantly and Smartlead support this natively in their settings, you just have to turn it on. Also auto-suppress anyone who booked a meeting in the last 90 days at the company level, so colleagues do not get hit while the relationship is active.
4. Layer 4: Set up the Clay enrichment lookup. In Clay, push your CRM suppression lists into a dedicated "block-list" table (use a webhook or the HubSpot integration to keep it synced). In every campaign-building Clay table, add a Lookup Rows action that checks each new contact's company domain against the block-list table. Set the lookup operator to "equals" on the normalised domain (lowercase, strip www and protocol). If there is a match at the company domain level, the contact never enters the sequence.
5. Add the safety check to Claude Code. In your CLAUDE.md for any campaign workflow, add: "Before pushing any leads to a sequencer, run them through the Clay block list lookup table. Any contact matching at the company domain level must be excluded from the campaign." This becomes a non-negotiable step in every list build.

What to expect

Initial setup takes a few hours: connecting OutboundSync, building the CRM lists, configuring sequencer rules, setting up the Clay lookup. After that the system runs on its own. Every new contact in any campaign gets four layers of checks before any email goes out. The first time the system catches a near-miss (a lead about to be hit who turns out to be a current customer) you understand why this is non-negotiable infrastructure.

---

09Workflow 9: Call Transcript Indexing into a Knowledge Base

What it is

Every demo call, sales call, and discovery call gets transcribed by Fireflies (or your tool of choice), then routed through Claude Code where the agent extracts competitor mentions, prospect frustration language, common objections, engagement patterns, and decision-maker signals. The output feeds a structured knowledge base that updates automatically every time a new call comes in.

What it helps with

Sales call transcripts are the highest-signal data source most teams have and the least used. Buried inside them is exactly which competitors come up in your space, the precise language prospects use when they're frustrated, the objections that stall deals, and the moments that pull people in. Operators running this at scale have indexed 500+ calls into a structured knowledge base and used it to build voice-of-customer copy and competitor displacement maps that consistently outperform copy written from intuition.

What you need

• Claude Code subscription
• Fireflies account with API access (Bearer token from Settings > Integrations > Fireflies API)
• A webhook receiver (a simple endpoint, or use n8n or Trigger.dev to handle the incoming webhook)
• GitHub repo for the knowledge base (or Notion if you prefer; both work)
• A sequencer connection if you want the knowledge base to drive copy generation downstream

Setup steps

1. Set up the Fireflies webhook. Go to Fireflies Settings > Developer > Webhooks. Add a webhook URL pointing to your endpoint (n8n, Trigger.dev, or a custom Cloud Function). Fireflies will fire a POST to that URL every time a transcript is ready. The payload contains a meetingId you'll use to fetch the full transcript via the GraphQL API. Set up secret verification using the x-hub-signature header so you can confirm requests are from Fireflies.
2. Build the transcript fetch step. When the webhook fires, your endpoint takes the meetingId and queries the Fireflies GraphQL API at api.fireflies.ai/graphql for the full transcript. Pull the sentences array (with speaker labels and timestamps), the summary, and the participants. Save the raw transcript to /transcripts/[date]-[client].md in your knowledge base repo.
3. Set up the extraction prompt. Create a Claude Code skill called transcript-extraction.md with the extraction logic: "For each transcript, extract: (1) competitor names mentioned and the exact context they came up in, (2) frustration language used by the prospect, (3) objections raised and how they were handled, (4) moments of high engagement (where the prospect leaned in), (5) decision-maker signals (titles, decision criteria, budget mentions). Output as structured Markdown with each category as a section."
4. Run the extraction on each new transcript. When a new transcript lands, prompt Claude Code: "Read /transcripts/[latest].md. Apply the transcript-extraction skill. Append the structured output to the relevant knowledge base sections." The structure typically includes /knowledge-base/competitors.md (running list of mentions plus dissatisfaction signals), /knowledge-base/objections.md, /knowledge-base/voice-of-customer.md (exact phrases and pain points), and /knowledge-base/engagement-patterns.md.
5. Build the competitor displacement map. Once you have 50+ transcripts indexed, prompt: "Read all competitor mentions across the knowledge base. Rank competitors by frequency of mention. For each one, summarize the dissatisfaction signals using the prospect's exact language. Output a competitor displacement map as a Markdown table." This becomes your single most valuable asset for copy.
6. Connect to copy generation downstream. When generating copy for a new campaign, reference the knowledge base: "Pull objection patterns from objections.md and prospect language from voice-of-customer.md. Build the email opener using the exact language prospects use when frustrated with [competitor]. Build the body around the most-cited objection." Now your copy is grounded in real customer language.
7. Backfill historical transcripts. If you have months of past calls in Fireflies, run a one-time backfill: query the transcripts list endpoint with pagination, fetch each transcript, and run the extraction against all of them. This jump-starts the knowledge base with historical signal before any new calls land.

What to expect

The first 50 transcripts feel like setup overhead. By transcript 100, the patterns are clear. By transcript 200+, the knowledge base is producing insights you would not have found by reading the transcripts manually (such as a competitor that comes up in 40% of churn calls but only 5% of demo calls). Voice-of-customer copy generated from this knowledge base consistently outperforms copy written from internal positioning.

---

10Workflow 10: Auto-Research Loop for Campaign Optimisation

What it is

A Claude Code agent that runs cold email experiments on a fraction of your sending volume, learns what works, and adapts the next experiment automatically. It pulls yesterday's campaign results, compares against baseline, redesigns the next experiment (different copy, different list filter, different signal), redeploys, stores what it learned, and repeats. Over time, the loop discovers winning patterns that human-written campaigns miss.

What it helps with

Marketing is testing. Most teams test slowly because every experiment takes manual work. This loop runs experiments continuously without you. You set the boundaries (offers allowed, audiences off-limits, copy rules that cannot be broken). The agent runs inside them. Operators running this on enterprise accounts allocate 10% of sending volume to the autonomous loop and have reported it outperforming their human-written campaigns within weeks.

⚠️ Important context before you start. This pattern is inspired by Andrej Karpathy's open-source AutoResearch repo (github.com/karpathy/autoresearch), released in March 2026. The original repo is built for ML model training experiments on a single GPU. It is not a cold email tool. What you are doing is adapting the same loop architecture (propose, run, measure, keep-or-rollback, repeat) to outbound campaign optimisation. You are not cloning Karpathy's repo and running cold email through it. You are building your own version using the same pattern, with Claude Code as the agent and your sequencer as the experiment runner.

What you need

• Claude Code subscription
• A sequencer with API access (Instantly, Smartlead, or lemlist) where you can programmatically launch and pause campaigns
• A reply intelligence loop already running (Workflow 7), since the agent needs reply data as its measurement signal
• A baseline campaign with known performance (this is the floor the agent measures against)
• Hard guardrails written into a markdown file before the loop runs

Setup steps

1. Read the original AutoResearch first. Go to github.com/karpathy/autoresearch. Read the README. Read program.md. Understand the loop pattern: read the program.md, propose a change, run a short experiment, measure the result, commit if better than baseline, roll back if not, repeat. You are not running this code. You are studying the pattern.
2. Write your guardrails markdown. Create a guardrails.md file in your Claude Code project. This is the equivalent of Karpathy's program.md, but for outbound. Include: which offers can be tested (and which cannot), which audiences are completely off-limits, copy rules that cannot be broken (no false claims, no fake scarcity, no aggressive urgency), the experiment volume cap (typically 10% of total sending volume), and the success metric (positive reply rate or meeting booked rate).
3. Define the experiment surfaces. In a separate experiments.md, list what the agent is allowed to vary. Common surfaces: subject line variants, opener variants (segmented by persona), CTA variants, sequence length (3 step vs 5 step), send-day timing, list filter parameters (job titles, company size, signal layers). For each surface, note the boundaries (such as: subject line under 50 characters, opener under 150 words).
4. Set the baseline. Pick one of your best-performing existing campaigns. This is the baseline the agent measures against. Lock in the metric (positive reply rate is most common). Run the baseline at full volume for at least 7 days so you have stable comparison data.
5. Build the loop in Claude Code. Prompt Claude Code: "Read guardrails.md and experiments.md. Pull yesterday's campaign results from [sequencer] for the experiment campaign. Compare positive reply rate against the baseline. If the variant beat baseline, mark the change as kept. If it lost, roll back. Then propose the next experiment from experiments.md, log the proposed change to /experiment-log/[date].md, redeploy the campaign with the new variant, and exit. Run again tomorrow."
6. Schedule the loop daily. Set the prompt to run on a daily cron via Trigger.dev or Railway. Each day the agent does one full cycle: measure yesterday, decide keep-or-rollback, design tomorrow, deploy tomorrow.
7. Add the human review checkpoint weekly. Once a week, review the /experiment-log to see what the agent has been trying and what worked. The agent runs autonomously inside guardrails, but a human should still skim the log weekly to catch anything that drifted in a direction you did not intend.

What to expect

The first 2 weeks usually produce small or no improvements as the agent explores. Around week 3-4, the loop starts finding non-obvious wins (subject line patterns, signal layers, persona segments) that humans tend to miss. By week 8-12, the autonomous campaign is often outperforming the human-written baseline on the same metric. The agent does not invent new strategies. It runs more experiments than humans have patience for.

---

11Closing notes

These 10 workflows represent what's actually being run at scale by GTM operators using Claude Code today. They're heavier to set up than dragging-and-dropping inside a sales engagement platform. The payoff is that once they're built, they compound. Every campaign feeds the next. Every reply teaches the system.

Where to start. Pick one workflow. Set it up properly. Watch how it changes the rest of your stack. Then layer in the next one.