
👋 Hi, it’s Rick Koleta. Welcome to GTM Vault - a breakdown of how high-growth companies design, test, and scale revenue architecture. Join 27,000+ operators building GTM systems that compound.
This episode in the Library: the written playbook, the stack and the full transcript, free and open. Open it at pro.gtmvault.co.
This episode is now a free Claude skill: MCP and API enrichment pipeline, built from the system Alexander Shartsis walks through here. See Alexander’s full stack on the Stack Index.
Show Me Your Stack, Episode 2: Enrichment Pipelines in Claude Code
This episode: Alexander Shartsis walks through an enrichment pipeline built in Claude Code, backed by a production-grade system powering Skyp’s managed outreach. A long list of MCP connections. Direct API layer underneath. Stage 3 agentic workflow. The breakdown below maps the build back to the Revenue Architecture.
The Targeting Failure That Enrichment Is Supposed to Solve
Most outbound campaigns fail silently. The emails go out. The open rates look reasonable. Nothing converts. The post-mortem blames the copy, the subject line, the send time, the offer. It is rarely any of those things.
The silent killer is list quality. The people on the list are the right title at the right company. They match the ICP on paper. But they are not in market. They have no documented need. No signal. No timing indicator. The campaign was dead before the first email was drafted because the enrichment layer did not produce signal. It produced demographics.
Alexander Shartsis has spent a year building Skyp’s enrichment and outbound system. Before that, he led M&A at Opendoor, closing four acquisitions in six months for a public company doing over two billion in revenue. He has bootstrapped, raised, exited, and shut down companies. He built Skyp because the enrichment problem is not a data gap. It is an architecture gap. The tools exist. The APIs exist. The failure is in how they are composed, what order they are called in, and whether anything upstream validates the output before it reaches the send layer.
In this episode, Alex builds a basic enrichment tool live in Claude Code using plan mode and the Apollo API, then walks through the production version that runs Skyp’s managed campaigns at roughly fifty cents per lead. The gap between those two builds is the entire argument for why enrichment is architecture, not a feature.
The Live Build: Claude Code Plan Mode to Working Tool
Alex starts the build on screen. Claude Code in the terminal. Plan mode activated with Opus for planning, Sonnet for code generation. The prompt is specific: build an enrichment tool that uses web search to find signals about people and Apollo API for email and contact information. Run locally. Keep it simple.
Claude returns a plan. A Python script. Data sources, structure, output format. Alex pauses here and makes a point that most people skip: read the plan before you execute it. Claude’s plan mode is not a formality. It is the architectural review. If the plan calls the wrong APIs, structures the data incorrectly, or misses a step, fixing it after execution costs more tokens and more time than catching it in the plan.
The distinction between Claude Code’s three modes matters here. Edit-after-asking mode does not plan. It reacts to the immediate task, builds the thing in front of it, then discovers downstream dependencies. Plan mode thinks through the whole system first, breaks it into steps, then executes sequentially. For anything beyond a single-file script, plan mode produces a fundamentally different output. Alex uses it for every build.
Claude recognizes that Alex has already built a larger enrichment app in the same repo. It asks why it is building a smaller version. This is worth noting. Claude Code maintains context across the project. If you have existing code that overlaps with the new build, it will flag it. Alex redirects it to build a standalone example.
The build runs. Claude writes the Python script, wires up the Apollo API, adds web search for signal enrichment. The output is functional. A founder or operator could take this script, point it at their ICP parameters, and get enriched leads with contact information and web-sourced signals for ten to twenty cents per lead.
This is the baseline. What Alex builds next is the production layer that turns a script into a system.
The MCP Stack and When Not to Use It
Alex’s Claude Code environment has a long list of MCP servers connected. He walks through the ones he uses most and what each one does in the workflow. But the architectural lesson is not “connect everything.” It is knowing when to use an MCP and when to drop to the API directly.

Gmail provides email history context. When building an outreach list, Claude can check Gmail to remove anyone Alex has already emailed. No manual deduplication. No CRM lookup. The MCP queries the inbox directly.
Grain is the meeting recorder. It has an MCP that lets Claude query meeting summaries and action items. The use case is follow-up prioritization: who did Alex meet with this week, what was discussed, who needs a follow-up. The data lives in Grain’s interface, but the MCP makes it queryable from the same environment where the enrichment runs.
Slack serves as the notification layer. Long-running enrichment processes send a Slack message when they finish. This is the difference between watching a terminal and doing other work while the system runs.
Intercom handles customer support content. Alex built an automation that runs every morning: it checks new GitHub commits, identifies product changes, and updates or creates Intercom help articles automatically. New features get flagged to Slack for human review before publishing. Existing feature changes publish directly.
Stripe provides the customer list. When building outreach lists, Claude pulls current customers from Stripe and removes them. No manual exclusion list. No stale CSV. The deduplication is live.
Ahrefs is the SEO and SEM data source. Competitive intelligence, keyword monitoring, website performance. This MCP is more of a data feed than an action layer.
Trigify monitors LinkedIn for signal data. It tracks people posting about specific topics and surfaces them as potential leads. The same function could be replicated with Claude web search, but Trigify packages it as a structured API.
Canva lets Claude build slides, mockups, and logos without leaving the terminal. Alex uses it for quick visual assets.
Calendar handles scheduling context. Meetings, availability, follow-up timing.
Skyp is the send layer. Once a list is enriched and validated, Claude pushes it directly to Skyp to start or add to a campaign. The full loop, from enrichment to send, runs without switching tools.
The rest are Claude’s built-in connectors (web search and others visible in the MCP list) that Alex uses but did not walk through individually.
The architectural insight is the cost tradeoff between MCPs and direct APIs. Every MCP call consumes tokens because the LLM reads the MCP documentation, constructs the request, and processes the response. A direct API call is just the raw request. For occasional tasks (checking Gmail, querying Grain), the token overhead is negligible. For high-volume operations (enriching hundreds of leads through Apollo), the overhead compounds. An hour-long enrichment run becomes two hours. Two hours becomes four.
Alex’s production system uses MCPs for convenience and context tasks. It uses direct APIs for the enrichment pipeline itself. The decision boundary is volume. If you are calling something ten times, use the MCP. If you are calling it a thousand times, use the API.

The Production System: Supervisor Agents and Self-Correcting Pipelines
The live build produces a functional script. The production system running inside Skyp is a different category of architecture. It is agentic. Not in the marketing sense of “we use AI.” In the structural sense that agents evaluate their own output and redirect the pipeline when quality degrades.
The system uses a supervisor agent pattern. The supervisor coordinates multiple sub-agents, each responsible for a different enrichment task: company discovery, people identification, signal extraction, email lookup. When a sub-agent returns results, the supervisor evaluates them before passing them downstream.
If the company list does not match the ICP parameters, the supervisor sends the discovery agent back with adjusted criteria. If the people found at those companies do not match the target titles, the supervisor discards them and requests a new search. If the signals returned are not relevant to the client’s product, the supervisor rejects them and specifies what signals to look for instead.
This is not keyword filtering. The supervisor agent has context about the client (pulled from website analysis), the target ICP, and the product’s value proposition. It makes judgment calls that a deterministic filter cannot. “This lead works at the right company but their LinkedIn activity suggests they just joined last month” is the kind of signal a supervisor agent catches and a static pipeline misses.
The system calls over a dozen enrichment APIs. The supervisor decides which ones to call based on what data is already present. If a lead already has a name and title but no email, it skips the discovery APIs and goes straight to the email lookup. If a lead has no company information, it starts with company identification before attempting contact enrichment. The routing is dynamic, not sequential.
This is Stage 3 in the revenue architecture classification. The system reads its own pipeline state. It adapts to data quality in real time. It spawns sub-agent tasks based on what is missing rather than executing a fixed sequence. The human intervention point is at campaign review before send, not at any point in the enrichment pipeline itself.

The Economics of Build vs. Buy vs. Hire
Alex makes a direct economic argument that cuts against the default advice in the GTM engineering community.
One company told Alex they were paying $800 to enrich 500 leads in Clay. That is $1.60 per lead for enrichment alone, before any outreach. Skyp’s managed service runs at roughly fifty cents per lead. A DIY build using Claude Code and direct APIs can get to ten to twenty cents per lead. The cost variance across these three approaches is an order of magnitude.
But cost per lead is not the full picture. The variable that kills most custom enrichment builds is time to production. Alex cites a company that hired a GTM engineer a month before the recording. Still no results. Still building. Still iterating on the workflow. No leads generated. No campaigns running. A managed tool like Skyp gets a team live in two weeks because that is how long it takes to warm up email infrastructure and configure the first campaign.
The structural argument is this: start with a vendor. Run it for a quarter. Learn what the enrichment problem actually looks like for your ICP. Learn which data sources produce signal and which produce noise. Learn what “good” enrichment output feels like when you are writing outreach against it. Then decide whether to build custom.
The risk of building first is that you do not know what you do not know. A GTM engineer who talked to Claude for ten minutes and built an n8n workflow is not the same as an operator who has run thousands of campaigns and understands which API call order produces the best data at the lowest cost. The job title is two years old. The quality variance across practitioners is enormous.
Alex is not arguing against GTM engineers. He works with them. His argument is narrower: for a two to ten person startup, the founder should either do it themselves or use a vendor before hiring someone to build a custom system. Hold the enrichment variable constant by using a known tool. Isolate product-market fit as the variable you are actually testing. Do not introduce two unknowns (new enrichment system and new outreach motion) at the same time.
The MCP Dependency Question
Alex makes a claim that has structural implications beyond this episode: he would not use a tool that does not have an MCP at this point.
The logic is straightforward. If a tool has an MCP, it can be composed into an agentic workflow. Claude can query it, act on its data, and chain it with other tools without the operator switching interfaces. If a tool does not have an MCP, it lives in its own UI, disconnected from the rest of the stack. It becomes a manual hop.
This is the same argument that played out with APIs a decade ago. Tools without APIs became integration dead ends. Tools without MCPs are becoming the same thing. The practical implication for operators evaluating tools: MCP support is no longer a nice-to-have feature. It is an architectural requirement for any tool that needs to participate in an agentic workflow.
The counterargument is cost. MCPs consume more tokens than direct API calls. At scale, the token overhead matters. Alex’s answer to this is layered: use MCPs for convenience and low-volume tasks, use direct APIs for high-volume pipeline operations. The MCP is the interface for the operator. The API is the interface for the system.
What to Measure and What to Ignore
The metrics that matter in this architecture are structural.
Cost per enriched lead. The direct dollar cost of every API call, web search, and LLM token consumed to produce one fully enriched lead with contact information and signal data. If this number is above a dollar, the pipeline is inefficient. At fifty cents managed or ten to twenty cents DIY, the system is viable. At $1.60 per lead in Clay, it is not.
Time to production list. How long from ICP definition to a list that is ready for outreach. The live build took roughly twenty minutes for a basic tool. The production system runs enrichment as a background process and sends a Slack notification when it finishes. If a human is still manually reviewing and cleaning lists for hours, the enrichment layer is not doing its job.
Supervisor rejection rate. In the agentic system, how often does the supervisor agent send a sub-agent back for a redo. A high rejection rate means the initial search parameters or API selection is wrong. A low rejection rate means the pipeline is well-calibrated. This metric does not exist in non-agentic systems, which is part of why they degrade silently.
Ignore total leads enriched, total API calls made, and total tokens consumed. These are throughput metrics. They describe volume, not quality. An operator who reports “we enriched 10,000 leads this month” without reporting cost per lead and downstream conversion rate is measuring the wrong layer.
What to Copy and What Depends on Context
Plan mode before execution. This is the most transferable pattern in the episode. Whether you are building an enrichment tool, a scraping pipeline, or any multi-step system in Claude Code, use plan mode with Opus first. Read the plan. Challenge it. Then execute. The upfront cost in time saves multiples in rework.
The MCP plus API layering pattern. Use MCPs for low-volume, high-context tasks (Gmail deduplication, Stripe customer exclusion, Grain follow-up queries). Use direct APIs for the high-volume pipeline operations (Apollo lookups, web search at scale). This cost management pattern applies to any agentic architecture, not just enrichment.
Vendor before custom build. If you have not run outbound campaigns before, start with a managed tool. Learn what good looks like. Then decide whether to build. This applies beyond enrichment to any GTM system where the operator does not yet have pattern recognition for what success looks like.
The supervisor agent pattern. If you are building agentic workflows that process data at scale, the supervisor pattern (an agent that evaluates sub-agent output and redirects when quality drops) is the difference between a pipeline that degrades silently and one that self-corrects. This requires more engineering than a linear pipeline. It is worth it at any volume above a few hundred leads.
What depends on context is the API selection. Alex uses Apollo for contact data, web search for signals, and a dozen other APIs for specific enrichment tasks. The specific vendors change with every ICP, every industry, every data need. The pattern of layered API calls with a supervisor evaluating output quality is the transferable piece. The vendor list is not.
Where This Build Sits in the Revenue Architecture

This build operates across the Signal, Data, and Execution layers.
At the Signal layer, the system solves the same core problem as Episode 1 but through a different mechanism. Instead of mining public reviews for latent pain signals, it uses web search and structured APIs to find people who match ICP criteria and have recent, relevant activity. The signal source is different. The architectural function is the same: convert unstructured information into a qualified pipeline input.
At the Data layer, the enrichment pipeline is the system’s primary function. Contact information, company data, signal context, email addresses. The MCP connections and direct API calls all feed into producing a structured lead record that contains enough context for personalized outreach. The supervisor agent’s quality checks operate at this layer, ensuring the data meets a threshold before it moves downstream.
At the Execution layer, this build goes further than Episode 1. The Skyp MCP connection means Claude can push an enriched list directly into an outbound campaign. The loop from signal identification to enrichment to campaign execution runs in a single environment. The human intervention point is campaign review, not list assembly.
The constraint is at the Measurement layer. The system produces enriched leads and sends campaigns. But the feedback loop from campaign performance back into enrichment quality is not fully automated. If certain signal types produce higher reply rates, that insight currently requires human analysis to feed back into the supervisor agent’s evaluation criteria. Closing that loop would move the system from Stage 3 agentic to the beginning of Stage 4 adaptive.
Timestamps
(0:00) Intro: Alexander Shartsis and the Skyp enrichment stack
(0:43) Kicking off the build in Claude Code plan mode
(2:06) Why enrichment: the silent killer is the wrong leads
(5:00) Reading the plan before you let Claude run it
(7:50) Running Claude Code inside Cursor with parallel agents
(9:16) Twelve MCPs: Gmail, Grain, Slack, Intercom, Stripe, Skyp
(11:28) MCPs vs direct APIs: when volume and cost matter
(20:42) The finished Skyp Enrich tool: four modes, fifty cents a lead
(24:19) Supervisor agents: how the pipeline judges its own output
(27:13) Do you need a GTM engineer? Start with a vendor
Full transcript, searchable to the timestamp: pro.gtmvault.co/episodes/smys-02.
On the record from this episode: Ahrefs, Apollo, Canva, Claude Code, Cursor, Gmail, Grain, Intercom, Slack, Stripe and Trigify. Each links to the operators who run it on The Stack Index.


