# ColdIQ's two May drops — the picture and the playbook

URL: https://www.thedeepfeed.ai/posts/2026-05-04-coldiq-19-api-claude-code-gtm-stack-audited/
Category: Tools
Published: 2026-04-24
Author: the-deep-feed
Tags: claude-code, gtm, coldiq, n8n, sales-engineering
Kind: deep

> Lieben's two May drops in 24 hours: the 19-API picture and the API-led GTM playbook underneath. What shipped, what's vapor, and the five-step migration that decides whether your skill survives team handoff.

## TL;DR

- On May 4, Michel Lieben dropped a 19-API map for running GTM from Claude Code at his bootstrapped $7M ARR agency. The post got **158 likes and 356 bookmarks** — operators saving for implementation, not reacting.
- Of the 19 vendors, **11 ship first-party MCP servers**, 4 have community-built MCPs only, and **4 (RB2B, Wiza, Vector.co, Openmart) have no Claude-native integration at all**. For those, Claude Code is emitting curl into n8n webhooks — same shape as a Zapier workflow from 2018.
- The stack costs **~$3,294/month at one user** and **~$13,795/month at five users**. Clay's Launch plan at **$185/month** replaces about 80 percent of it. ColdIQ's own '$7M funnel' blog post lists Clay first.
- The actual integration substrate is **czlonkowski/n8n-mcp** at 20,134 stars — not the vendor MCPs. Claude drives n8n; n8n drives the 19 APIs. The headline picture and the wiring diagram are different pictures.
- Lieben's GTM skill pack lives at [sachacoldiq/ColdIQ-s-GTM-Skills](https://github.com/sachacoldiq/ColdIQ-s-GTM-Skills) — 98 SKILL.md files, Anthropic-spec compliant, 117 stars in 90 days, last push **Feb 19, 2026**. The repo is a marketing artifact, not a maintained product. The day after the 19-API post, Lieben publicly pivoted the same engine to Hermes Agent.

![Schematic: 19 vendor blocks split into 11 wired direct and 8 routed via a red ring (n8n). The wiring under the headline.](/post-images/2026-05-04-coldiq-19-api-claude-code-gtm-stack-audited/two-arrow-types.jpg)

On May 4, **Michel Lieben**, CEO of [ColdIQ](https://coldiq.com) (a bootstrapped Belgian outbound agency Lieben says is at $7M ARR), published a numbered list on X. ["Run GTM from Claude Code with these APIs (full step-by-step breakdown)"](https://x.com/MichLieben/status/2051286894206656782). The breakdown was 19 vendors across seven layers: signal, data, action, automation, CRM, conversion, revenue. The stack diagram below the tweet ran in three colors and showed the pipeline as a single flow from "intent lives" to "revenue gets tracked."

The thread itself is text. The picture below it is editorial. Both did the rounds.

The numbers on the tweet are the right place to start. **158 likes, 10 retweets, 11K impressions, and 356 bookmarks** — a save-to-like ratio of 2.25x. People aren't reacting to it. They're stashing it to implement. On a thread that has the form of a recommendation list, that ratio is a buyer signal: GTM operators are reading the tweet as a parts inventory and intend to assemble.

Whether the parts assemble is the question this piece answers.

# The 19 APIs, layer by layer

The 19 names, in his own ordering [from the May 4 thread](https://x.com/MichLieben/status/2051286894206656782):

| Layer | Tools |
|---|---|
| **Signal** (where intent lives) | PredictLeads, Common Room, Attention, RB2B |
| **Data** (where contacts get enriched) | Apify, Wiza, Prospeo, FullEnrich, Openmart, Apollo, Vector AI |
| **Action** (where outreach happens) | Instantly, Lemlist, LinkedIn Ads |
| **Automation** | n8n, Claude (Anthropic) |
| **System of record** | Attio |
| **Conversion + revenue** | Cal.com, Hyperline, Dreamdata |

The framing is classic operator content. Each tool gets one line, the role is named, and the picture stitches them with arrows. Three sentences at the bottom summarize the pitch: full-cycle outbound from signal to CRM update with no manual steps; self-healing pipelines that fall back to alternative providers when one fails; agents that monitor signals around the clock.

Underneath the pitch is the artifact. Lieben has been [publicly giving away ColdIQ's playbook](https://x.com/MichLieben/status/2039674012008435902) since at least early April, and the actual code lives on GitHub at [`sachacoldiq/ColdIQ-s-GTM-Skills`](https://github.com/sachacoldiq/ColdIQ-s-GTM-Skills). The repo holds **98 SKILL.md files** in seven master skills (`clay`, `cold-email`, `linkedin-ads`, `linkedin-content`, `list-building`, `n8n`, `signal-sourcer`) plus 33 standalone skills. It is structurally compatible with Anthropic's [Agent Skills spec](https://github.com/anthropics/skills): YAML frontmatter, `.claude/skills/` subdirectories, drop into a Claude Code project and the assistant picks it up. 117 stars, 24 forks, last push **February 19, 2026** — a static drop, not a maintained product. The repo is published under `sachacoldiq`, a one-repo team account; Lieben's [personal GitHub](https://github.com/MichLieben) is dormant, last pushed Le Wagon Ruby exercises in 2018.

The first interesting fact is that the master skill called "clay" exists. The first item in the data layer of Lieben's own Claude Code skill repo is the very tool the 19-API stack is implicitly arguing against. ColdIQ's [own published post](https://coldiq.com/blog/the-tech-stack-behind-our-7m-funnel) titled *"The Tech Stack Behind Our $7M Funnel"* lists Clay as the first data-sourcing tool. The 19-API map is a marketing artifact. The shipped repo is the operating manual. They disagree, on purpose.

# The integration substrate, layer by layer

![ColdIQ's 7-layer GTM stack from signal to revenue — automation (in editorial red, the load-bearing middle layer where 4 of 19 vendors live) connects the upstream data pipeline to the downstream conversion-and-revenue workflow.](/post-images/2026-05-04-coldiq-19-api-claude-code-gtm-stack-audited/gtm-7-layers.jpg)

The technical claim under "Run GTM from Claude Code" is that the 19 APIs are *callable from Claude*. In Anthropic's design vocabulary the way this happens is the [Model Context Protocol](https://modelcontextprotocol.io): a tool registers an MCP server, Claude Code adds it as a connector, the model can invoke functions on that server with arguments and read structured returns. That's the high-fidelity story. The low-fidelity story is curl: Claude generates HTTP calls and either runs them in the terminal or hands them to n8n, which runs them.

Both shapes are real. They have different reliability and security properties. The piece that gets dropped from screenshots is which shape applies to which vendor.

The MCP coverage scoreboard, drawn from each vendor's own documentation as of May 6, 2026:

| Vendor | First-party MCP? | Source |
|---|---|---|
| Apollo.io | ✅ | [apollo.io/product/mcp](https://www.apollo.io/product/mcp) |
| Common Room | ✅ | [commonroom.io/product/mcp-server](https://www.commonroom.io/product/mcp-server/) |
| Attio | ✅ | [docs.attio.com/mcp/overview](https://docs.attio.com/mcp/overview) |
| Cal.com | ✅ | [github.com/calcom/cal-mcp](https://github.com/calcom/cal-mcp) |
| FullEnrich | ✅ | [fullenrich.com/mcp](https://fullenrich.com/mcp) |
| Apify | ✅ | [docs.apify.com/platform/integrations/mcp](https://docs.apify.com/platform/integrations/mcp) |
| Lemlist | ✅ | [developer.lemlist.com/mcp/setup](https://developer.lemlist.com/mcp/setup) |
| Hyperline | ✅ | [docs.hyperline.co/api-reference/docs/ai/mcp](https://docs.hyperline.co/api-reference/docs/ai/mcp) |
| Instantly.ai | ✅ partial | [help.instantly.ai/...instantly-mcp](https://help.instantly.ai/en/articles/12980002-instantly-mcp-model-context-protocol) |
| PredictLeads | ✅ | [docs.predictleads.com/mcp_integration](https://docs.predictleads.com/mcp_integration) |
| Dreamdata | ⚠️ via Zapier | [zapier.com/mcp/dreamdata](https://zapier.com/mcp/dreamdata) |
| n8n | ⚠️ community | [czlonkowski/n8n-mcp](https://github.com/czlonkowski/n8n-mcp) |
| Wiza | ⚠️ via Composio toolkit | [composio.dev/toolkits/wiza](https://composio.dev/toolkits/wiza) |
| Attention | 🔴 none | n/a |
| RB2B | 🔴 none | n/a |
| Prospeo | 🔴 none | n/a |
| Openmart | 🔴 none | n/a |
| Vector.co | 🔴 none | n/a |
| Anthropic Claude | n/a (it is the client) | n/a |

![Bar chart: 19 bars descending tall sepia to short red. MCP coverage as height.](/post-images/2026-05-04-coldiq-19-api-claude-code-gtm-stack-audited/mcp-coverage.jpg)

Eleven of the nineteen ship first-party MCP servers and they all do real work: Apollo's MCP exposes search, enrichment, and sequence operations; Attio's exposes the entire CRM record graph; FullEnrich's runs the 28-provider waterfall as a single tool call. For those eleven, "run GTM from Claude Code" is operationally accurate. The model invokes a function. The function runs. The result comes back as structured data the model can reason over.

The bottom four are the problem. Lieben's RB2B, Attention, Vector.co, Openmart, Prospeo, and Wiza paragraphs all read like the model is calling them. None of them publish an MCP server. To use them from Claude Code, the agent has to either generate a curl request and run it as a bash tool, or push a webhook into n8n which then calls the vendor's REST API. That is not a Claude-Code-native integration. That is the same shape every Zapier and Make automation has had since 2018 — except now with a chatbot in front. The story shifts from *"the agent can natively orchestrate 19 tools"* to *"the agent can natively orchestrate 11 tools and emits HTTP for the other 8."*

This is not a small distinction in production. First-party MCPs come with auth lifecycles, rate-limit handling, schema versioning, and retry policies maintained by the vendor. Curl-into-n8n means the agent maintains all of that, which means an LLM is responsible for keeping API contracts straight as vendors version. That fails open during model upgrades.

There is one more wrinkle. Lieben writes "Vector AI" and links to a domain that returns 404. The legacy [vector.ai](https://vector.ai/) was a logistics platform that [rebranded to Raft.ai](https://salestechstar.com/price-optimization-revenue-management/vector-ai-rebrands-to-raft-to-consolidate-automation-success-into-its-intelligent-freight-forwarding-platform/) and is unrelated to GTM. The product Lieben means is **Vector.co**, a [YC-backed](https://www.ycombinator.com/launches/KGY-vector-turn-your-company-s-network-into-pipeline) website-de-anonymization tool. Sloppy citation in the source material is itself a tell: the picture is downstream of the parts.

# The actual wiring diagram

The substrate that makes "Claude Code drives the 19 APIs" work is not the vendors' MCP servers. It's a single community repo: [`czlonkowski/n8n-mcp`](https://github.com/czlonkowski/n8n-mcp), at **20,134 stars** as of May 6. The repo's pitch is to "give Claude Code complete knowledge of all 535 n8n nodes," which functionally means Claude Code can read, write, and execute n8n workflows from inside a session. n8n already has community nodes or webhook recipes for every major SaaS. Once Claude can drive n8n, it can drive whatever n8n can drive — which is approximately everything.

The companion repo [`czlonkowski/n8n-skills`](https://github.com/czlonkowski/n8n-skills) (4,833 stars) ships the SKILL.md packs that wrap n8n operations as Claude Code skills. Together they are the de facto integration layer for the entire genre.

What this means for Lieben's diagram:

| Surface story | Wiring under the surface |
|---|---|
| Claude → 19 APIs | Claude → `n8n-mcp` → n8n → 19 APIs |
| Self-healing pipelines | n8n's retry + fallback nodes |
| Agents that monitor 24/7 | n8n cron triggers + webhooks |
| MCP-native orchestration | 11 vendors via MCP, 8 via curl-through-n8n |

n8n is not minor. The 186K-star core platform is doing the heavy lifting Lieben's diagram credits to "Claude Code." The model is the orchestrator. n8n is the execution engine. Apollo, Attio, Common Room, and the other first-party MCP vendors are the tools the orchestrator can call directly without the n8n hop. The other eight vendors live behind n8n.

This is why the 19-API stack is implementable but the picture is misleading. An honest version of Lieben's diagram has Claude Code at the top, n8n in the middle as a ring around the model, and two arrow types from n8n outward: solid lines for the eleven MCP-native vendors, dashed lines for the eight curl-from-webhook ones. The diagram with one arrow type implies one integration shape. There are two.

# Clay is the elephant

The diagram's other tell is what's missing. **Clay** does not appear in Lieben's 19. It is the incumbent every signal-data-enrichment vendor in the list compares itself to.

Clay's 2025 ran fast. [$1.5B tender offer](https://techcrunch.com/2025/05/08/clay-authorizes-employee-tender-at-a-1-5b-valuation-led-by-sequoia/) led by Sequoia in May, then [$100M Series C at $3.1B valuation](https://techcrunch.com/2025/08/05/clay-confirms-it-closed-100m-round-at-3-1b-valuation) led by CapitalG in August. Clay's positioning page now opens with "the GTM engineering era begins now." Their pricing publishes [openly](https://www.clay.com/pricing): Free with 100 Data Credits and 500 Actions per month, **Launch starting at $185/month** with 2,500 Data Credits and 15,000 Actions, then Growth and Enterprise tiers with custom pricing.

The Launch plan replaces:

- **150+ provider data waterfall** (Lieben uses Apollo + Wiza + Prospeo + FullEnrich + Openmart, ~$208/mo for one user)
- **Job-change and hiring-spike signal tracking** (Lieben uses PredictLeads + Common Room, ~$1,740/mo at startup tier)
- **AI personalization** (Lieben uses Claude Code itself, $17/mo Pro)
- **Email sequencer** (Lieben uses Instantly + Lemlist, ~$100/mo per user)
- **Audience syncs to Ads platforms** (Lieben uses LinkedIn Ads natively)

Clay does not perfectly cover all five — the email sequencer is light, the visitor de-anonymization (RB2B's slot) requires a separate add, and the CRM (Attio's slot) sits outside Clay's surface. But the 80 percent it does cover ships behind one auth, one schema, and one bill at $185/month versus the equivalent slice of the 19-API stack at roughly $1,948/month for the same scope. The Lieben stack is **10.5x more expensive** than Clay alone for the slice they overlap on.

The Clay vs Lieben argument is not "is Clay enough." For some teams it's not. The argument is whether the integration tax of running 19 vendors plus n8n plus Claude Code plus a custom skill repo is justified by what those 19 do that Clay can't. The honest answer is that the marginal additions are real — Vector.co's website-de-anonymization is meaningfully different from Clay's intent signal mix; Hyperline solves a billing problem Clay doesn't touch; Dreamdata's attribution is a separate category. The dishonest answer is the one the diagram tells, which implies the 19 are required to do GTM from Claude Code. They aren't. Eleven of them are MCP-native and would slot into a Clay-centered stack just as well. Five of them solve problems Clay solves first.

ColdIQ knows this. ColdIQ's [own published $7M-funnel post](https://coldiq.com/blog/the-tech-stack-behind-our-7m-funnel) names Clay first under "Data Sourcing" (alongside Openmart and LinkedIn) and only mentions Apollo as a [waterfall fallback](https://coldiq.com/blog/the-50-tools-behind-our-6-5m-arr-agency). The 19-API picture is the picture ColdIQ shows when the topic is "how to run GTM from Claude Code." It is not ColdIQ's actual stack. For "how ColdIQ actually books $7M," Clay is in the lineup.

# The total cost

The total bill on the 19-tool stack at two real configurations, using each vendor's published 2026 pricing:

**Startup tier — one user, basic volume:**

| Tool | Plan | $/mo |
|---|---|---|
| PredictLeads | $40 floor | 40 |
| Common Room | Starter | 1,700 |
| Attention | demo-only, est. one seat | ~99 |
| RB2B | Basic | 149 |
| Apify | Starter | 29 |
| Wiza | Email | 83 |
| Prospeo | Starter | 37 |
| FullEnrich | Starter | 29 |
| Openmart | sales-led, est. | ~200 |
| Apollo.io | Basic 1 seat | 49 |
| Vector.co | sales-led, est. | ~300 |
| Instantly.ai | Growth | 38 |
| Lemlist | Email Pro 1 seat | 63 |
| n8n | Starter | 22 |
| Claude Code | Pro | 17 |
| Attio | Plus 1 seat | 29 |
| Cal.com | Teams | 12 |
| Hyperline | base | 199 |
| Dreamdata | Free | 0 |
| **Total** | | **~$3,294/mo** |

**Scaleup tier — five users, real volume:**

| Tool | Plan | $/mo |
|---|---|---|
| PredictLeads | 10K calls | 100 |
| Common Room | Team est. | 4,000 |
| Attention | 5 seats est. | 495 |
| RB2B | Premium | 499 |
| Apify | Scale | 199 |
| Wiza | Email + Phone × 5 | 830 |
| Prospeo | Pro | 187 |
| FullEnrich | Scale | 500 |
| Openmart | est. | 500 |
| Apollo.io | Organization × 5 | 595 |
| Vector.co | est. | 1,000 |
| Instantly.ai | Hypergrowth | 78 |
| Lemlist | Multichannel × 5 | 435 |
| n8n | Pro | 54 |
| Claude Code | Max 20× × 5 | 1,000 |
| Attio | Pro × 5 | 345 |
| Cal.com | Org × 5 | 140 |
| Hyperline | base + 0.6% × $100K rev | 799 |
| Dreamdata | est. | 2,000 |
| **Total** | | **~$13,795/mo** |

![Two towers: tall sepia stack of 19 slabs beside a single short red slab. The 19-tool cost vs Clay as architecture.](/post-images/2026-05-04-coldiq-19-api-claude-code-gtm-stack-audited/cost-towers.jpg)

For comparison: Clay Launch alone is $185/month. Apollo.io Organization for five seats is [$595/month](https://www.apollo.io/pricing). Clay plus Apollo plus Cal Free plus Attio Plus for one user is $263/month. The hand-built minimum (Apollo Basic, n8n self-hosted free, Claude Code Pro, Attio Free, Cal Free) is $66/month.

The 19-tool stack at scaleup tier costs $165,540 a year. Clay Launch costs $2,220 a year. The math is not close.

This isn't an argument that the cheap stack does the same work. It's an argument that the expensive stack's additional cost has to earn out against four to seven orders of magnitude of overhead, every month, across 19 vendor relationships, and that almost no team running it should expect to. The picture flattens this trade-off. Operators reading it as a parts list are likely to underestimate the integration debt and overestimate the marginal yield.

# The genre, not the tool

Step back from Lieben's specific list. The pattern underneath it is brand new and worth naming.

In **September 2025**, Anthropic published the [Agent Skills spec](https://claude.com/blog/skills) — a YAML-frontmatter SKILL.md format that lets Claude Code load procedural knowledge as a directory of files. Boris Cherny's account of how skills work is the [Lenny's Newsletter interview](https://www.lennysnewsletter.com/p/head-of-claude-code-what-happens) and his [tweet thread](https://x.com/bcherny/status/2007179832300581177). The Deep Feed's [own piece on this](https://www.thedeepfeed.ai/posts/2026-04-29-stop-using-claude-code-like-a-chatbot/) covered the developer-tooling side of the skill format.

The non-developer side took longer to show up. Anthropic shipped [`anthropics/knowledge-work-plugins`](https://github.com/anthropics/knowledge-work-plugins) on January 23, 2026 — the first official Anthropic plugin pack with `sales/` and `marketing/` skill bundles. The [sales skills](https://github.com/anthropics/knowledge-work-plugins/tree/main/sales) shipped at nine: `account-research`, `call-prep`, `call-summary`, `competitive-intelligence`, `create-an-asset`, `daily-briefing`, `draft-outreach`, `forecast`, `pipeline-review`. The accompanying [`CONNECTORS.md`](https://github.com/anthropics/knowledge-work-plugins/blob/main/sales/CONNECTORS.md) named Anthropic's blessed integration substrate: HubSpot or Close as the default CRM, **Clay or ZoomInfo or Apollo** as the default data layer, Outreach as the default sales engagement, Fireflies as the default conversation intel.

Nine skills, blessed substrate, and the substrate has Clay on it.

Then the agency-as-distribution pattern showed up. Within sixty days of Anthropic's January drop:

| Repo | Created | Stars | Source |
|---|---|---|---|
| `sachacoldiq/ColdIQ-s-GTM-Skills` | Jan 30 | 117 | [link](https://github.com/sachacoldiq/ColdIQ-s-GTM-Skills) |
| `getaero-io/gtm-eng-skills` | Feb 21 | 17 | [link](https://github.com/getaero-io/gtm-eng-skills) |
| `ivangfalco/gtm-skills` | Feb 27 | 17 | [link](https://github.com/ivangfalco/gtm-skills) |
| `gooseworks-ai/goose-skills` | Mar 2 | 656 | [link](https://github.com/gooseworks-ai/goose-skills) |
| `growthenginenowoslawski/coldoutboundskills` | Mar 10 | 209 | [link](https://github.com/growthenginenowoslawski/coldoutboundskills) |
| `Othmane-Khadri/gtm-engineer-playbook` | Mar 11 | 38 | [link](https://github.com/Othmane-Khadri/gtm-engineer-playbook) |
| `LessieAI/lessie-skill` | Mar 30 | 20 | [link](https://github.com/LessieAI/lessie-skill) |
| `ivangfalco/ads-skills` | Apr 7 | 77 | [link](https://github.com/ivangfalco/ads-skills) |
| `sales-skills/sales` | Mar 23 | 15 | [link](https://github.com/sales-skills/sales) |

![Schematic: central master tile with 12 satellites, one red. The SKILL.md spec at center, the agency-genre fanning out.](/post-images/2026-05-04-coldiq-19-api-claude-code-gtm-stack-audited/agency-genre.jpg)

Twelve of these emerged in ninety days. None existed before February 2026. The shape is consistent: a GTM agency or solo operator publishes its proprietary playbook as a SKILL.md repo, lets Claude Code users install it directly, and uses the repo as inbound marketing for the consultancy. Eric Nowoslawski's [GrowthEngineX repo](https://github.com/growthenginenowoslawski/coldoutboundskills) is structurally identical to ColdIQ's and has been getting more recent updates. Othmane Khadri's [GitHub bio](https://github.com/Othmane-Khadri) reads "i am open sourcing all the GTM stack." The genre is real.

The economic logic is straightforward. A skill repo is a Trojan horse for a sales conversation. Whoever installs the skill is by definition running Claude Code, has GTM problems, and downloaded the agency's mental model verbatim. Of the people who install, most won't deploy. The ones who do hit edge cases that turn into consulting calls. Lieben said it out loud on April 6:

> Most companies who download it won't implement a fraction of it. The ones who do become clients anyway.
>
> — [@MichLieben](https://x.com/MichLieben/status/2041138615598952854), Apr 6, 2026

The skill repo replaces the gated lead magnet. The format Anthropic published in September became the agency-marketing primitive of the spring.

This is the most interesting thing about Lieben's tweet. The 19-API list will be wrong in three months because the underlying tools will have shipped or killed MCPs. The ColdIQ skill repo will be stale because ad campaigns and email templates churn. But the *genre* (agency open-sources its operating system as Claude Code skills) is structurally durable. Anthropic's spec turned the GTM playbook into a unit of distribution. The agencies are using it.

# 2.25 bookmarks per like: an implementation-intent signal

Back to the engagement numbers. **158 likes, 356 bookmarks** on the 19-API tweet — 2.25 bookmarks per like. Lieben's [flagship ad-skills give-away](https://x.com/MichLieben/status/2047307021687611676) earlier in April pulled 4,068 likes, 364 retweets, 432K impressions; that one was a hit. The 19-API drop got modest engagement on likes and outsized engagement on bookmarks. Operators saving for later, not reacting in the moment.

![Torn-paper collage: small sepia rectangle with a heart beside a larger red one with a bookmark flag. The 2.25x bookmark ratio.](/post-images/2026-05-04-coldiq-19-api-claude-code-gtm-stack-audited/save-vs-react.jpg)

This matches what Lieben's broader timeline shows. His top tweet of the period by raw engagement was the [$5,000 LinkedIn cash incentive](https://x.com/MichLieben/status/2039432665078923529) experiment (6,158 likes, 438K views), which is a story tweet, not a stack tweet. The stack content gets bookmarked. The story content gets reacted to. The 356 bookmarks on the 19-API drop are not a viral signal; they're an implementation-intent signal from a much smaller cohort.

The cohort matters because it's defining the genre. [Yann Dine](https://x.com/yanndine/status/2047311264041316698) has 7,500 followers and shipped a 10-module Claude GTM Notion doc he says 3,000+ founders requested in a month. [Eric Nowoslawski](https://x.com/ENowoslawski) hits 4,000 followers and runs a Claude-Code-as-GTM-substrate stack. [Adam Robinson](https://x.com/RetentionAdam/status/2050612827832918388) runs RB2B and Retention.com at "$8.4M ARR with 3 people" and reposts Claude Code clones of Typeform "built in 4 hours." [Aaron Will](https://x.com/IAmAaronWill/status/2051254021608886285) describes a five-tool collapse (Clay, n8n, Claude, Instantly, Notion) to 286K followers. The founders are small but the message is propagating.

What's also propagating is the counter-current. Three days after Anthropic shipped the new rate ceilings:

> Day 3 of unusable Claude Code limits — we have started to move our skills over to Codex.
>
> — [@ENowoslawski](https://x.com/ENowoslawski/status/2039332003133169989), Apr 1, 2026

The substrate is fungible. Lieben himself, [the day after the 19-API drop on May 5](https://x.com/MichLieben/status/2051708750764105788), posted a Hermes Agent demo of "the same engine running on Hermes Agent instead of Claude Code." One day. Same engine. Different model.

This is the part the picture leaves out. The 19 APIs are real. The skill format is real. The wiring through n8n is real. What's not durable is "Claude Code" as the load-bearing word in "run GTM from Claude Code." The load-bearing word is **skills** — the SKILL.md format, the agency repos, the operating manual that runs the same on Claude or Codex or Hermes. Lieben already showed it.

# What ships, what's vapor

A scorecard at the level the diagram works.

🟢 **Ships, today, at the level the tweet implies:**

- Apollo, Attio, Common Room, Cal.com, FullEnrich, Apify, Lemlist, Hyperline, Instantly, PredictLeads (first-party MCP, Claude Code can call them)
- ColdIQ skill repo at [`sachacoldiq/ColdIQ-s-GTM-Skills`](https://github.com/sachacoldiq/ColdIQ-s-GTM-Skills) — 98 SKILL.md files, drop-in
- n8n + `czlonkowski/n8n-mcp` as the orchestration ring around Claude

🟡 **Ships, but the integration is not what the picture implies:**

- RB2B, Wiza, Vector.co, Openmart, Prospeo, Attention have no first-party MCP. Claude reaches them via curl or n8n webhook. Functional, but not Claude-Code-native. The "self-healing pipeline" claim depends on n8n's retry behavior, not Claude's.
- Dreamdata via Zapier MCP works, but the integration substrate is a Zapier wrapper, not the vendor's own
- "Vector AI" in the thread points to a domain that returns 404; the right vendor is Vector.co

🔴 **Vapor, at the level the tweet implies:**

- "GTM agents that monitor signals around the clock" is implementable in part. But production-grade 24/7 agent ops at this stack's complexity have a different cost profile than $3,294/month and require ops staff the picture doesn't price in
- "Self-healing pipelines that retry failures and fall back to alternative providers automatically" leans on n8n's retry features. Doing it across 19 vendors with consistent error semantics is real engineering, not a config switch.
- "Full-cycle outbound from signal detection to CRM update with zero manual steps" is possible at small volumes, fragile at large ones. The teams running this report constant skill maintenance and prompt-tuning. The skills-as-OS framing implies one-time setup; the maintenance is recurring.

The picture is roughly two-thirds true. The third that isn't is the third that costs the most to discover.

# The playbook underneath the picture

The 19-API list dropped on May 4. Twenty-four hours earlier, on May 3 at 20:02 UTC, Lieben had posted a long-form X article titled [*"The Complete Guide to API-Led GTM"*](https://x.com/MichLieben/status/2051029582070141119). 101 likes, 443 bookmarks, 2 retweets, 60,082 impressions. A **4.4× bookmark-to-like ratio** — almost twice the 2.25× on the 19-API tweet that came the next day. Operators saved the *how* in even higher proportion than they saved the *what*.

The picture is what shipped. The playbook is how to ship it.

The audit asked whether the 19 names were real. The next question is what the migration actually looks like — and where the failure modes hide.

# Layers, not tools

Lieben's framing in the long-form article is single-sentence:

> *"Look at any SaaS in a typical B2B GTM stack and the value sits in the API behind the screen."*

The argument is that operators have been paying for API access bundled with a UI built for human ops. Once an agent can read API docs, make the call, parse the response, and route the result, the dashboard is overhead. The pricing model was a tax on the human bottleneck. Remove the bottleneck, the tax stops mapping to value. **Stop thinking about tools. Start thinking about layers.**

Each layer is a job in the GTM motion. Each job has interchangeable API providers. The agent's instructions stay the same when you swap providers because the layer's role hasn't changed.

![Axonometric stack of seven sepia slabs with the middle Automation layer in red. The seven-layer GTM picture as architecture.](/post-images/2026-05-04-coldiq-19-api-claude-code-gtm-stack-audited/seven-layers.jpg)

The seven layers Lieben names map onto the same vendors the 19-API picture lists, but with a different intent — the layer is the unit, the vendor is fungible:

| Layer | Job | Preferred APIs |
|---|---|---|
| Signal | Find what's worth working at all | PredictLeads, Common Room, Trigify, RB2B, Vector |
| Data | Turn signals into contactable records | Apollo, AI Ark, CompanyEnrich, Prospeo, FullEnrich, Wiza |
| Action | Where the campaign fires | Instantly, Lemlist, LinkedIn Ads, Meta Ads |
| Automation | Orchestrates the rest | Claude Code, n8n, Relevance AI, Conductor |
| System of record | Shared state file | Attio |
| Conversion | Get the meeting and bill it | Cal.com, Hyperline |
| Revenue | Attribute back to source | Dreamdata |

Pick one API per layer. Substitute providers at the layer level (CompanyEnrich for AI Ark, Lemlist for Instantly) without changing workflow structure. The agent calls the new API the same way it called the old one because the agent's job description was *"enrich emails for this list"* — not *"call Apollo with these arguments."*

This is the mental model. The migration playbook below is what happens when you take it seriously.

# Three workflows running in production

Before the playbook, the proof-of-concept. Lieben names three workflows currently running on the stack at ColdIQ or its clients. None of them are vapor — they're cited in tweets, walkthroughs, or articles. The framing is selective in ways worth flagging.

**Workflow 1: 300-account outbound campaign in under 20 minutes.** Walkthrough by Kenny on the ColdIQ team. AI Ark surfaces 300 SaaS companies (200–500 headcount) from a 70M-company database in under two minutes. PredictLeads layers hiring/tech/launch signals: 186 actively hiring, 114 dropped. BlitzAPI finds Director/VP/C-suite decision-makers via ICP waterfall. Limadata fills email gaps BlitzAPI missed. FullEnrich cascades through 20+ providers and hits a 95% mobile match rate on the surviving list. Instantly creates the campaign, pushes leads, configures sending (plain text, no HTML, deliverability-optimized) and parks it in draft for human review. After launch, Claude pulls Instantly analytics, identifies which personas responded, builds lookalikes of the best performers, and feeds the next campaign. Lieben's framing: *"outbound auto-improves like a retargeting pixel."* The phrase is rhetorically tight. The implementation is fragile. Lookalike construction quality depends on the analytics granularity Instantly exposes (campaign-level open and reply rates, not multivariate attribution), and the "auto-improves" claim depends on whether the next campaign actually gets sent, which is a human-review checkpoint, not an automated step. What's real: the 300-account list build → enrichment → campaign draft in under 20 minutes is achievable today. The auto-tuning loop is aspirational.

**Workflow 2: paid ads from the terminal at $300K/month.** Run by Ivan, ColdIQ's head of growth. ICP matrix → company/contact sourcing → email enrichment via Prospeo. Brand specs extracted from existing creative, stored in a skill the agent reads at session start. [fal.ai](https://fal.ai) generates creative variations across 600+ image and video models through a single endpoint. LinkedIn Ads and Meta APIs handle audience uploads, campaign builds, and bid configuration. Custom skills handle bulk edits across platforms, audience uploads, and creative-fatigue detection. Lieben's claim: *"once the skills folder matured, output doubled without sacrificing quality."* The $300K/month figure is spend volume, not agency revenue. The actual labor multiplier isn't quantified. The closest comparable in the open-source skill ecosystem is [`AgriciDaniel/claude-ads`](https://github.com/AgriciDaniel/claude-ads), a 4,141-star repo with 250+ checks across Google, Meta, YouTube, LinkedIn, TikTok, and Microsoft Ads. That repo isn't the one Ivan is running, but it's the closest public reference.

**Workflow 3: LinkedIn outreach from one terminal.** Built with Othmane Khadri at [Earleads](https://www.earleads.com) and demonstrated in a 54-minute masterclass titled *"How to Run a LinkedIn Outbound Campaign Entirely Inside Claude Code."* Khadri's GitHub profile [`Othmane-Khadri`](https://github.com/Othmane-Khadri) lists Earleads as company and ships a public [`gtm-agent-playbook` repo](https://github.com/Othmane-Khadri/gtm-agent-playbook) with `outreach-packager` and `meeting-prep-brief` skills. The flow: list build → qualification → personalized drafts → outreach, all from a single prompt. Four-layer architecture: input, `CLAUDE.md`, skills, `memory.md`. Seven-gate qualification pipeline running underneath the chat surface. [Unipile](https://www.unipile.com/messaging-api) for multi-account LinkedIn outreach (safe ceiling: 20–25 connection requests per day per inbox). [Apify](https://apify.com) for social scraping. [Firecrawl](https://firecrawl.dev) for company-page parsing. The seven-gate qualification pipeline is the part most teams underbuild. Lieben doesn't enumerate the gates. Operators reading the playbook should treat *"seven-gate qualification"* as a placeholder until they see Khadri's masterclass — gates are where the policy lives, and policies that aren't visible can't be audited.

# The five-step migration

This is the spine of the article. The format is prescriptive, not aspirational. Each step has a defined output and a defined success criterion.

**Step 1: set up the runtime.** Install Claude Code or Conductor on top of it. Create a project folder with `CLAUDE.md`, an empty `.claude/skills/` directory, and a `.env` file. Spend an afternoon on `CLAUDE.md`: ICP definition, scoring rules, tool preferences, voice guidelines for cold-email copy. The hard rule: **`CLAUDE.md` stays under 200 lines.** The five-step migration is what you do *after* `claude /init`, `claude /sandbox`, and the basic MCP loadout are in place. `CLAUDE.md` loads on every session (permanent context tax). Skills load on demand. Push everything that isn't *always* needed into a skill. The substrate Lieben assumes is the one we covered in [*Stop using Claude Code like a chatbot*](/posts/2026-04-29-stop-using-claude-code-like-a-chatbot/).

**Step 2: pick the first workflow.** Connect Claude Code to Apollo. Write one skill. The skill description Lieben suggests verbatim: *"score a CSV of leads against my ICP and return the top 50%."* Run the skill on a real Apollo export. The constraint: small enough to ship in one session, concrete enough that the value is immediately legible. Lead scoring is a deliberate choice — it's the highest-frequency, lowest-stakes scoring decision in B2B outbound. The output is a ranked list. The agent isn't deciding to send anything yet. There's nothing to revert. The published [`anthropics/skills`](https://github.com/anthropics/skills) reference repo and the [Anthropic Agent Skills spec](https://www.anthropic.com/engineering/claude-code-best-practices) are the relevant prior art. YAML frontmatter (`name`, `description`, optional `metadata`, optional `allowed-tools`), `.claude/skills/<skill-name>/SKILL.md` directory layout, three lines of frontmatter, one paragraph of instructions, zero ceremony.

**Step 3: run it deterministically twice.**

![Two inputs descending into a central node, two output strips with identical tier divisions, a small red checkmark confirming the match.](/post-images/2026-05-04-coldiq-19-api-claude-code-gtm-stack-audited/determinism-test.jpg)

This is the test that decides whether Step 2 ships or gets rewritten. Run the same skill on a second Apollo export. The same scoring rule must produce the same tiering on the same accounts. If it doesn't, the policy is sitting in the prompt instead of in the markdown — it won't survive being handed to a teammate. **Move the policy into the markdown until the second run matches the first.**

Lieben calls it the determinism test, but the framing is slightly looser than the term suggests. LLM scoring isn't deterministic — temperature, sampling, context-window position, and prompt drift all introduce variance. What Lieben means is reproducibility: the *tiers* must match, even if the per-account scores drift by a few points. The acceptance test isn't `output_v1 == output_v2`; it's that the top-50% bucket is materially the same set of accounts across runs.

The test exists because the most common failure mode in agent-driven GTM is exactly this: the operator who wrote the skill can run it because the rules live half in the markdown, half in the way they phrase the prompt. The skill works for them. They hand it to a teammate. Output drifts. Trust collapses. The determinism test is the cheapest forcing function for moving policy from prompt to markdown. The discipline of running every new skill on two inputs and rewriting until tiers match is the closest thing in this playbook to engineering rigor.

This is also the test that connects the playbook to a deeper argument. [Karpathy's Software 3.0 framing](/posts/2026-05-01-karpathy-software-3-agentic-engineering/) reads natural-language prompts as a programming surface. The determinism test is what separates a *program* (reproducible, handoff-able, version-controllable) from a *prompt* (situated in the head of one operator). A skill that fails the determinism test is a prompt with delusions of being a program.

**Step 4: add the next layer.** Connect Instantly. Build the cold-email campaign workflow on the scored list from Step 2. Two skills are now chained — output of the first feeds the second. Add PredictLeads or FullEnrich next so signals layer onto scoring before copy gets generated. The rule Lieben states verbatim: **each new layer = one markdown file + one API key.** What the rule masks: each new API also adds a new failure mode. Apollo's MCP rate-limits independently of FullEnrich's. PredictLeads has its own auth flow. The skill that works on a 100-row list breaks on a 10,000-row list because the agent didn't model batching. The framing makes this sound additive. In practice it's compositional, and the composition has gaps. The teams Lieben writes about have already paid the debugging tax. New migrators will pay it on the first 10K-row run. The five workflow patterns Anthropic named in [*Building Effective Agents*](https://www.anthropic.com/research/building-effective-agents) map onto these layers (we walk that mapping in [the WizOfEcom audit](/posts/2026-05-03-wizofecom-5-agent-personal-brand-content-engine-audited/)). Production-grade ColdIQ-style stacks run the orchestrator-workers variant, which isn't in the public playbook because the substrate is its own engineering investment.

**Step 5: fork the config.** After your first campaign ships, the saved scripts in `.claude/skills/` are the start of your institutional memory. Copy the entire project folder for the next client or campaign. **Rewrite only the two voice-specific files**: scoring criteria and copy frameworks. Everything else carries over. Onboarding becomes a writing exercise.

This is the part that turns Lieben from operator into agency-distribution thinker. The skill folder isn't a tool, it's a unit of replication. Every new client gets the same `CLAUDE.md` template, the same eighteen skills, two voice-specific overrides, and an API-key swap. The work that used to be a 90-day implementation engagement collapses into a directory copy. Whatever margin the agency was earning on implementation gets eaten. Whatever margin the agency was earning on *taste* (the two voice files) becomes the entire business.

This is also why the public skill repos matter even if no one ever runs them in production. The marketing-side equivalent of the GTM-skill cluster is significantly larger — a May 2026 [scan of the marketing-skills landscape](https://github.com/search?q=topic%3Aclaude-skills+marketing) surfaces 480+ repos. Quality is heavily bimodal: a handful of polished, MIT-licensed monorepos with versioning and CI; a long tail of hastily-cloned skill packs with names like `r04-…-seo` that look programmatically forked. The four canonical leaders, by stars and meta-quality:

| Repo | Author | Stars | What's in it |
|---|---|---|---|
| [`coreyhaines31/marketingskills`](https://github.com/coreyhaines31/marketingskills) | Corey Haines | 26,287 | 40 SaaS-marketing skills, the reference template |
| [`AgriciDaniel/claude-seo`](https://github.com/AgriciDaniel/claude-seo) | Daniel Agrici | 5,946 | 24 SEO sub-skills, 12 specialist subagents |
| [`AgriciDaniel/claude-ads`](https://github.com/AgriciDaniel/claude-ads) | Daniel Agrici | 4,141 | 250+ checks across Google, Meta, YouTube, LinkedIn, TikTok |
| [`thatrebeccarae/claude-marketing`](https://github.com/thatrebeccarae/claude-marketing) | Rebecca Rae | 26 | 56 versioned skills, Klaviyo/Braze/GA4/Looker first-class |

For the full landscape (480+ repos, four canon leaders, four conspicuous gaps) see [*The 480-repo marketing-skill cluster on GitHub*](/posts/2026-05-05-marketing-skill-cluster-github-480-repos-four-gaps/). Step 5 is what creates that market. Every operator who runs the five steps once produces an artifact. Some open-source it. That's the engine behind the genre.

# What the playbook leaves out

The five steps are clean. The omissions matter.

**MCP coverage isn't named.** The audit above showed 11 of 19 vendors ship first-party MCPs, 4 reach Claude through partial integrations, and 4 don't reach Claude at all. The playbook is silent on this. A new operator following Steps 1–5 against a vendor without an MCP will end up writing curl wrappers or n8n bridges they didn't budget for. The path of least resistance is [`czlonkowski/n8n-mcp`](https://github.com/czlonkowski/n8n-mcp), a 20K-star bridge that lets Claude Code orchestrate n8n workflows. For one-third of Lieben's stack, n8n isn't an option but a requirement.

**The cost of failure isn't named.** A skill that fails Step 3's determinism test is fixable. A skill that passes the test but writes to Apollo, Attio, or Instantly with wrong data is the failure mode that kills the migration. The playbook has no rollback layer. There's no "Step 3.5: write the failing-action runbook." Production teams running this stack at scale have learned the cost the hard way. The article doesn't pre-compute it for the reader.

**The cost of API spend isn't named at the right resolution.** Lieben writes elsewhere that *"one ColdIQ agent spent $4,200 in API credits in a single month and no one told it to stop."* That's the strongest argument both for why seat-based pricing is dying *and* for why an unsupervised migration kills you. The agent doesn't budget. Neither does the playbook. Apollo, FullEnrich, and Prospeo all bill per call. A poorly-scoped skill in a loop will exhaust a month's enrichment budget in a session.

**The seven-gate qualification pipeline isn't enumerated.** Step 2 says "small enough to ship in one session." Workflow 3 says "seven-gate qualification running underneath." Both true, both at different ends of the maturity curve. New migrators will start at Step 2's lead-scoring skill and assume Step 5's fork-able config produces Workflow 3's pipeline. It does not. The middle is six months of debugging.

**The team profile isn't named.** Step 5 implies one operator with a writing habit. Workflow 2 implies a head-of-growth supervising the agent. Workflow 3 implies a masterclass with a domain partner. The labor profile is fluid throughout, and the *"GTM engineer replaces a 3-person SDR pod"* line isn't sized against headcount or salary. Correct in shape, rhetorical in number.

# What the playbook gets exactly right

The omissions are real. The argument is also correct in the parts that matter.

**Layer thinking beats tool thinking.** The seven-layer breakdown is the cleanest framing of a B2B GTM stack written down anywhere. Once a task maps to a layer, the choice of API stops being a religious decision. CompanyEnrich vs AI Ark is a procurement question, not a strategy question.

**Skills as institutional memory works.** The fork-the-folder pattern is the right unit. It compresses onboarding the way Git compressed code-sharing. Every operator who has open-sourced a skill repo since February 2026 has run a small variant of Lieben's Step 5. The genre's existence is the empirical proof.

**The determinism test is load-bearing.** It's the cheapest, most enforceable reproducibility check the agent-skills ecosystem has. Operators running this test on every new skill will end up with a stack that survives team handoff. Operators skipping it will end up with skills that work for one author and confuse everyone else. The test is what separates a skill from a saved prompt.

**`CLAUDE.md` under 200 lines is the right constraint.** Every line in `CLAUDE.md` is a tax paid on every session, every prompt, every token-budget calculation. Making it the first instruction in the migration is correct.

**The pricing-model thesis is correct.** *"Pricing models inside the stack reprice themselves"* is the cleanest one-line statement of why seat-based SaaS bills are inverting. Clay's per-action pricing is the leading indicator. The full thesis (that agent-driven workloads will force action-priced billing across the GTM stack) is the strongest piece of forward-looking analysis in either of Lieben's May posts.

# What to do with this if you're an operator

The playbook is shorter to act on than to read.

🟢 **Run Step 1 today.** Install Claude Code, write a 200-line `CLAUDE.md`, drop the [Anthropic skills repo](https://github.com/anthropics/skills) and [`wshobson/agents`](https://github.com/wshobson/agents) into your project as reference. Cost: an afternoon. Risk: zero.

🟢 **Run Step 2 against Apollo this week.** The lead-scoring skill is the right entry point because it's read-only against your existing data. Use the [Apollo MCP](https://www.apollo.io/product/mcp) as your first connection — it's first-party, the rate limits are documented, and the failure modes are discoverable.

🟡 **Run Step 3 against two Apollo exports before connecting Instantly.** The determinism test is the gate between Step 2 and Step 4. Don't skip it. Don't add the action layer until tier reproducibility is real.

🟡 **Pick your skill-pack reference deliberately.** [`coreyhaines31/marketingskills`](https://github.com/coreyhaines31/marketingskills) is the canonical SaaS-marketing template. [`thatrebeccarae/claude-marketing`](https://github.com/thatrebeccarae/claude-marketing) is the highest-meta-quality (versioned, tested, frontmatter discipline). [`gtmagents/gtm-agents`](https://github.com/gtmagents/gtm-agents) is the closest match for B2B sales-led teams. Fork one. Don't fork all of them.

🔴 **Skip the migration if your motion doesn't match.** Lieben names four disqualifiers in his article: sales cycles measured in days, buyers who don't live in digital channels, compliance environments that won't approve agent actions on customer data, solo founders sending under 50 cold emails per week. Each is correct. The migration earns its rent on volume and asynchrony. Without both, the setup overhead is bigger than the win.

# The real fight: integration bundle vs. operating manual

GTM tooling has had two waves in two years. The first wave was Clay, which took 150+ enrichment providers, packaged the waterfall into one product, and added an AI agent for personalization. The second wave is the one Lieben is mid-ride. It rewrites Clay's bundle as a directory of SKILL.md files and a Claude Code agent that orchestrates 19 specialist vendors. The first wave got to $3.1B. The second wave's largest practitioner is bootstrapped at $7M ARR and giving the playbook away.

The substantive disagreement between the two waves is about where the value sits. Clay says it sits in the integration: one auth, one schema, one bill, one agent that knows the schema. Lieben's argument says it sits in the operating manual: pick best-of-breed at every layer, glue with Claude Code and n8n, and let the agency open-source the procedural knowledge as skills. Both can be right for different teams. The honest case for the Lieben approach is teams that already have the engineering muscle to maintain 19 vendor relationships and want best-of-breed signal coverage. The honest case for Clay is everyone else.

The marketing case for the Lieben approach is the picture. The picture overstates the integration uniformity, understates the n8n dependency, sidesteps the cost math, and leaves out Clay despite Clay being on ColdIQ's own production stack. None of this is fatal to the underlying argument. The GTM-skill-pack genre is real and growing. Anthropic's spec turned procedural agency knowledge into a distributable artifact. Twelve agencies have already shipped one. The format will outlast Claude Code as the specific runtime — Lieben's own one-day pivot to Hermes Agent demonstrates exactly that.

What stays after the substrate churn is the SKILL.md file. What goes is the picture. The one to bookmark, and operators are already bookmarking, is the [`sachacoldiq` repo](https://github.com/sachacoldiq/ColdIQ-s-GTM-Skills), not the diagram. The 98 files in there are the actual artifact, last touched February 19, 2026, free to fork. Whether they're worth installing depends on whether the team installing them has Clay underneath.

ColdIQ does. The picture doesn't say so.

# Sources

The base thread: Lieben's [May 4 19-API drop](https://x.com/MichLieben/status/2051286894206656782). The skill repo: [`sachacoldiq/ColdIQ-s-GTM-Skills`](https://github.com/sachacoldiq/ColdIQ-s-GTM-Skills). The integration substrate: [`czlonkowski/n8n-mcp`](https://github.com/czlonkowski/n8n-mcp). Anthropic's official sales pack: [`anthropics/knowledge-work-plugins/sales`](https://github.com/anthropics/knowledge-work-plugins/tree/main/sales). The incumbent: [Clay pricing](https://www.clay.com/pricing) and [Series C coverage](https://techcrunch.com/2025/08/05/clay-confirms-it-closed-100m-round-at-3-1b-valuation). The data layer comparison: [Apollo $150M ARR](https://www.apollo.io/magazine/apollo-reaches-150-million-arr-fueled-by-ai), [Apollo.io pricing](https://www.apollo.io/pricing). The genre context: Boris Cherny on [Lenny's Newsletter](https://www.lennysnewsletter.com/p/head-of-claude-code-what-happens). The cohort: Adam Robinson on [RB2B at 3 people / $19M ARR](https://newsletter.rb2b.com/p/19m-arr-w-9-fte-early-plays-rb2b-retention-com), Eric Nowoslawski's [coldoutboundskills](https://github.com/growthenginenowoslawski/coldoutboundskills), Lieben's [own pivot to Hermes Agent](https://x.com/MichLieben/status/2051708750764105788) one day after the 19-API thread.

The companion long-form Lieben published 24 hours earlier, [*"The Complete Guide to API-Led GTM"*](https://x.com/MichLieben/status/2051029582070141119), is the source for the five-step migration and the determinism test folded in above. For the marketing-side equivalent of the GTM-skill cluster (480+ repos, four canon leaders, four conspicuous gaps), see [*The 480-repo marketing-skill cluster on GitHub*](/posts/2026-05-05-marketing-skill-cluster-github-480-repos-four-gaps/). For the personal-brand variant (Mubbu's 5-agent content engine, gated rather than open), see [*WizOfEcom's 5-agent content engine, audited*](/posts/2026-05-03-wizofecom-5-agent-personal-brand-content-engine-audited/).

The Deep Feed's [companion piece on Claude Code as a developer surface](https://www.thedeepfeed.ai/posts/2026-04-29-stop-using-claude-code-like-a-chatbot/) covered the engineering side of the same skills format ColdIQ is using as a marketing primitive. The two pieces describe the same Anthropic spec landing in two different operator populations a few months apart.

## Sources

- [Lieben — 19 APIs that turn Claude Code into a full GTM engine (X)](https://x.com/MichLieben/status/2051286894206656782)
- [ColdIQ — The Tech Stack Behind Our $7M Funnel](https://coldiq.com/blog/the-tech-stack-behind-our-7m-funnel)
- [sachacoldiq/ColdIQ-s-GTM-Skills (GitHub)](https://github.com/sachacoldiq/ColdIQ-s-GTM-Skills)
- [anthropics/skills (GitHub)](https://github.com/anthropics/skills)
- [anthropics/knowledge-work-plugins — sales (GitHub)](https://github.com/anthropics/knowledge-work-plugins/tree/main/sales)
- [czlonkowski/n8n-mcp (GitHub)](https://github.com/czlonkowski/n8n-mcp)
- [Clay pricing](https://www.clay.com/pricing)
- [Clay — $100M Series C at $3.1B (TechCrunch)](https://techcrunch.com/2025/08/05/clay-confirms-it-closed-100m-round-at-3-1b-valuation)
- [Apollo.io pricing](https://www.apollo.io/pricing)
- [Apollo — $150M ARR](https://www.apollo.io/magazine/apollo-reaches-150-million-arr-fueled-by-ai)
- [Anthropic — Series F at $183B post-money](https://www.anthropic.com/news/anthropic-raises-series-f-at-usd183b-post-money-valuation)
- [Anthropic — Series G at $380B post-money](https://www.anthropic.com/news/anthropic-raises-30-billion-series-g-funding-380-billion-post-money-valuation)
- [Boris Cherny on Lenny's Newsletter](https://www.lennysnewsletter.com/p/head-of-claude-code-what-happens)
- [Common Room — MCP Server](https://www.commonroom.io/product/mcp-server/)
- [Apollo.io — MCP product page](https://www.apollo.io/product/mcp)
- [Attio — Building the Attio MCP Server](https://attio.com/engineering/blog/building-the-attio-mcp-server)
- [FullEnrich — MCP server](https://fullenrich.com/mcp)
- [Apify — MCP server](https://docs.apify.com/platform/integrations/mcp)
- [Lemlist — MCP setup](https://developer.lemlist.com/mcp/setup)
- [Hyperline — MCP docs](https://docs.hyperline.co/api-reference/docs/ai/mcp)
- [Cal.com — MCP server](https://github.com/calcom/cal-mcp)
- [Vector.ai → Raft.ai rebrand](https://salestechstar.com/price-optimization-revenue-management/vector-ai-rebrands-to-raft-to-consolidate-automation-success-into-its-intelligent-freight-forwarding-platform/)
- [RB2B — $19M ARR with 9 FTE](https://newsletter.rb2b.com/p/19m-arr-w-9-fte-early-plays-rb2b-retention-com)
- [growthenginenowoslawski/coldoutboundskills (GitHub)](https://github.com/growthenginenowoslawski/coldoutboundskills)
- [Lieben — flagship Claude Code ad-skills give-away (X)](https://x.com/MichLieben/status/2047307021687611676)
- [Lieben — $5K LinkedIn employee experiment (X)](https://x.com/MichLieben/status/2039432665078923529)
- [Lieben — Hermes Agent pivot (X)](https://x.com/MichLieben/status/2051708750764105788)
- [Adam Robinson — RB2B less-than-one-man machine (X)](https://x.com/RetentionAdam/status/2050612827832918388)
- [Michel Lieben — The Complete Guide to API-Led GTM (X long-form)](https://x.com/MichLieben/status/2051029582070141119)
- [Michel Lieben — Skill-as-lead-magnet thesis (April 6)](https://x.com/MichLieben/status/2041138615598952854)
- [Michel Lieben — Open-sourcing the GTM stack](https://x.com/MichLieben/status/2039674012008435902)
- [Michel Lieben on X](https://x.com/MichLieben)
- [ColdIQ — agency homepage](https://coldiq.com)
- [Anthropic — Claude Code Best Practices](https://www.anthropic.com/engineering/claude-code-best-practices)
- [Aaron Will — five-tool sales stack](https://x.com/IAmAaronWill/status/2051254021608886285)
- [Yann Dine — Claude GTM Notion doc](https://x.com/yanndine/status/2047311264041316698)
- [Eric Nowoslawski — GrowthEngineX](https://x.com/ENowoslawski)
- [Othmane Khadri — Earleads (GitHub profile)](https://github.com/Othmane-Khadri)
- [Earleads](https://www.earleads.com)
- [Attio — MCP integration help](https://attio.com/help/apps/other-apps/model-context-protocol-mcp)
- [Instantly.ai — webhooks API](https://developer.instantly.ai/api/v2)
- [Lemlist — API](https://developer.lemlist.com)
- [Cal.com — public API](https://cal.com/docs/api-reference/v2/introduction)
- [Hyperline — webhooks](https://docs.hyperline.co/integrations/webhooks)
- [Dreamdata — for Claude (Zapier MCP)](https://dreamdata.com/integrations/zapier)
- [PredictLeads — API docs](https://predictleads.com/docs)
- [Common Room — API](https://www.commonroom.io/api)
- [FullEnrich — waterfall enrichment](https://www.fullenrich.com)
- [Prospeo — email finder](https://prospeo.io)
- [Wiza — LinkedIn-to-contact API](https://wiza.co/api)
- [Apify — data extraction](https://apify.com)
- [Firecrawl — web crawling](https://firecrawl.dev)
- [Unipile — multi-account LinkedIn](https://www.unipile.com/messaging-api)
- [fal.ai — image and video models](https://fal.ai)
- [n8n — official site](https://n8n.io)
- [Conductor — Claude Code orchestration](https://conductor.build)
- [Relevance AI](https://relevanceai.com)
- [Boris Cherny — How I use Claude Code](https://x.com/bcherny/status/2007179832300581177)
- [Boris Cherny — 10 tips from the Claude Code team](https://x.com/bcherny/status/2017742741636321619)
- [Anthropic — Building Effective Agents](https://www.anthropic.com/research/building-effective-agents)
- [coreyhaines31/marketingskills](https://github.com/coreyhaines31/marketingskills)
- [AgriciDaniel/claude-ads](https://github.com/AgriciDaniel/claude-ads)
- [thatrebeccarae/claude-marketing](https://github.com/thatrebeccarae/claude-marketing)
- [gtmagents/gtm-agents](https://github.com/gtmagents/gtm-agents)
- [Othmane-Khadri/gtm-agent-playbook](https://github.com/Othmane-Khadri/gtm-agent-playbook)
- [wshobson/agents (Claude Code agents)](https://github.com/wshobson/agents)

---

Canonical: https://www.thedeepfeed.ai/posts/2026-05-04-coldiq-19-api-claude-code-gtm-stack-audited/
Site: https://www.thedeepfeed.ai
Full corpus: https://www.thedeepfeed.ai/llms-full.txt