Lemlist Campaign From Icp

Lemlist Campaign From ICP

Turn a natural-language ICP prompt into a paused live lemlist campaign — leads sourced from lemlist's People Database, agentically enriched, routed by seniority, sequenced, refined, scored against the 244K-campaign benchmark, and pushed into a real lemlist account in PAUSED state for human review.

The user types one prompt. The skill chains 24 lemlist atomic skills + the lemlist MCP server. Approval gates fire before the campaign is created in lemlist. Nothing auto-sends.

When This Skill Applies

• "create a lemlist campaign for VPs of Sales at Series B SaaS hiring AEs in Europe"
• "build a lemlist campaign from this ICP: …"
• "spin a lemlist campaign for managers in HR Tech using paid LinkedIn jobs"
• "ICP to lemlist"
• "natural language to lemlist campaign"
• "draft a lemlist campaign for me"

Prerequisites

LEMLIST_API_KEY=         # https://app.lemlist.com → Settings → Integrations

OAuth alternative (interactive use): claude mcp add --transport http lemlist https://app.lemlist.com/mcp.

The lemlist MCP must be connected. Verify with /mcp in Claude Code — you should see operations like get_lemleads_filters, lemleads_search, create_campaign_with_sequence, add_sequence_step, add_lead_to_campaign, set_campaign_state, validate_campaign_readiness, campaign stats, etc.

This skill depends on the 24 atomic lemlist skills bundled under .claude/skills/lemlist/. They were imported from lemlist's open-source skill library under MIT. See .claude/skills/lemlist/README.md for the attribution and update procedure.

Hard safety contract (MANDATORY)

This skill creates a campaign in a real lemlist account using paid lemlist credits (sourcing + agentic enrichment). It must never auto-send. Safeguards:

1. DRAFT state is the default. Campaigns are created in DRAFT state by default via create_campaign_with_sequence. The orchestrator MUST NOT call set_campaign_state with action start. Verify with validate_campaign_readiness before reporting readiness to the user. The campaign stays in DRAFT in the user's lemlist account until the user starts it manually in the lemlist UI.
2. Dryrun first. Render the full sequence text, the lead list summary, the persona routing breakdown, and the estimated lemlist credit usage to a local JSON file at ~/.gtm-os/lemlist-campaign-from-icp/dryrun-{timestamp}.json. Quote the file path back to the user.
3. Lead count ceiling. Default cap is 50 leads per run. The user can raise it with an explicit instruction, but the skill always quotes the number back before sourcing.
4. Hard approval prompt. After the dryrun, the skill asks "Approve creating campaign '{title}' in lemlist with {N} leads and the sequence above? Type 'approve' to push, anything else to abort." Block on the user response. Do not call any campaign-creation or lead-add MCP tool until the user types approve.
5. No silent retries. If any MCP creation/add call fails, surface the error and stop. Do not retry without explicit user instruction. Known unstable endpoint (verified live, 2026-05-19): set_campaign_state action archive can return HTTP 500 intermittently — never retry blindly; surface the error and let the user clean up via the lemlist UI.

When Claude invokes this skill on a user's behalf:

1. ALWAYS produce the dryrun output first.
2. Quote the EXACT lead count and the EXACT campaign title back to the user.
3. WAIT for explicit user approve before calling any campaign-creation or lead-add MCP tool.
4. Only proceed past dryrun after the user has approved the spend in this conversation.

Stage handoff contract (what to extract and carry forward)

Each substrate skill returns prose. Claude must extract the listed fields at each stage and persist them in a working memory object that the orchestrator threads forward. If a field cannot be extracted, apply the fallback. Never proceed past stage 17 with empty emails[].

End-to-end orchestration (25 stages)

The skill walks Claude Code through the following chain. Each stage names the lemlist atomic skill or MCP operation it invokes.

Stage 1 — Strategic foundation (7 skills)

For each step below, invoke the lemlist atomic skill at .claude/skills/lemlist/{skill-name}/SKILL.md. Capture the structured output and feed it forward.

1. icp-definer — turn the user's natural-language prompt into a structured ICP (firmographics, geography, signal triggers).
2. persona-definer — derive specific buyer personas from the ICP. Each persona carries a seniority tier (VP+ / Manager / IC).
3. pain-identifier — for each persona, identify evidence-based pain points based on growth signals, tech stack, hiring activity.
4. value-prop-lister — extract value props from the user's product context (if shared) or ask the user to confirm 2–3 anchor value props.
5. offer-definer — transform value props into outcome-focused offers, one per persona.
6. competitor-finder — identify 2–3 obvious competitors per persona; generate differentiation angles to weave into the copy.
7. trigger-finder — identify buying triggers (funding rounds, exec hires, tool changes) that the messaging can reference.

Stage 2 — Sourcing (3 skills + 2 MCP ops)

Lemlist's filter registry can change. Always discover filterIds at runtime rather than hardcoding.

8. company-finder — translate the ICP into a lemlist firmographic search configuration (industry, size, geography, technographics).

9. list-builder — combine the firmographic config with signal filters (e.g., active hiring, funding signals) into a single search shape.

10. people-finder — translate persona seniority + role into lemlist People Database search filters. 11a. MCP call: get_lemleads_filters — fetch the active filter registry.

    Payload size warning (verified live, 2026-05-19): the response is ~93K chars / 3,091 lines and cannot fit in an LLM context window in a single tool result. When the MCP returns "result exceeds maximum allowed tokens, output saved to <path>", grep that file for the specific filterIds you need (currentTitle, seniority, country, region, currentCompanyHeadcount, department, currentCompanySubIndustry, etc.) plus their values arrays. Do NOT attempt to load the full registry into chat.

    Use the returned filterId values to shape the search filters array. UI-only filters (notInContacts, notInCampaign) are not available over this transport — drop them if surfaced by upstream skills.

    Industry-filter leak warning (verified live, 2026-05-20): currentCompanySubIndustry has no clean "B2B SaaS" bucket. The two closest values are Software Development and Technology, Information and Internet, but the latter contains marketplace and consumer-internet companies. When the user's ICP says "B2B SaaS" (or "B2B software"), the orchestrator MUST layer a keywordInCompany filter on top of the subindustry filter — recommended seed terms: ["B2B", "SaaS", "B2B software", "B2B platform"]. Without this layer, non-SaaS leads will leak through and waste sourcing credits.

11b. MCP call: lemleads_search with mode: "people" (or "companies", never "leads") and a filters array of {filterId, in, out} objects derived from stage 11a. Cap size at the lead count ceiling (default 50, max 100 per page). Dedupe results by linkedin_url and email before storing in working memory.

**Company-level dedup (verified live, 2026-05-20):** for VP+ persona targeting where the buyer is the only decision-maker per company, also dedupe by `current_exp_company_name`. This is governed by the `dedupe_by_company` knob, defaulted ON for `seniority_tier: VP+` and OFF for `Manager` and `IC` tiers (where multiple champions per company are useful). When the knob drops a lead, surface the dropped lead in the dryrun's `deduped_leads[]` array with the kept lead's id so the user can override.

**Payload size warning (verified live, 2026-05-19):** each lead returns ~24K chars; a 5-lead call already exceeds 122K chars, a 50-lead call would exceed 1MB. Two mitigations the orchestrator MUST apply:
1. **Pass `excludes`** to drop heavyweight nested objects you don't need at this stage (recommended baseline: `excludes: ["experiences", "interests", "languages", "inferred_skills", "lead_logo_url", "company_description", "techno_used_array"]`).
2. **Expect the response to be saved to a file** by the MCP host when over the context limit. Grep/parse that file with a small script to extract only the per-lead fields needed for stage 12 forward: `full_name`, `potential_email`, `lead_linkedin_url`, `current_exp_company_name`, `country`, `headline`, `seniority`, `department`. Do NOT attempt to load the full response into chat.

Stage 3 — Enrichment posture

12. lemleads_search returns search results, not imported leads. Search results include a potential_email field for most (but not all) leads. The orchestrator does NOT toggle the per-call enrichment flags (findEmail, verifyEmail, linkedinEnrichment, findPhone) on add_lead_to_campaign by default — those cost credits per flag per lead.

    Lead email coverage (verified live): in real searches, 70-85% of leads ship with a potential_email; the rest have null or missing. The orchestrator must compute and surface an email_coverage_percent figure in the dryrun (stage 24) so the user can decide what to do with the gap.

    Three paths to fill the gap, in order of preference:

    1. Skip leads without email. Cheapest; reduces effective list size.
    2. Use a Yalc enrichment skill (fullenrich-plg-reverse-lookup, fullenrich-content-engagers, fullenrich-network-activation, fullenrich-event-attendees, or enrich-with-signals) — these run through the fullenrich MCP server and resolve emails from LinkedIn URL + name + company. Recommended path: enrich the missing-email subset via the appropriate fullenrich skill BEFORE stage 25d, then re-merge.
    3. Toggle lemlist's findEmail: true on add_lead_to_campaign — fastest but per-lead-per-flag credit cost. Only use when the user explicitly opts in via an instruction like "enrich emails through lemlist" before approval. Quote the projected credit cost back to the user during the dryrun.

Stage 4 — Per-lead personalization angle

13. linkedin-outbound-angle — for each lead, analyze the enriched LinkedIn profile and pick the strongest personalization angle. Store per-lead.

Stage 5 — Campaign design (2 skills)

14. campaign-angle-finder — generate 3 distinct campaign angles for the target persona using the ICP, pains, offer, and triggers. Pick the top angle (or surface the 3 to the user for a one-line decision).
15. outbound-campaign-architect — design the high-level sequence structure (number of touches, channel mix, timing) using lemlist's benchmark data (244K campaigns, 249M emails).

Stage 6 — Routing + writing (5 skills, conditional)

16. Route by seniority based on persona-definer output:
    • VP+ → copywriting-vp-sequence
    • Manager → copywriting-manager-sequence
    • IC → copywriting-ic-sequence
17. Invoke the routed skill with the enriched lead, the offer, the angle, and the trigger context. Output: a 3-email sequence per persona tier.
18. copywriting-first-touch — tighten the opener of each sequence using the per-lead angle from stage 13.
19. copywriting-follow-up — write the follow-up email(s) with fresh angles, citing the pain points from stage 3 and the triggers from stage 7.
20. cta-designer — design reply-worthy CTAs per email. Replace generic asks with value-based prompts.

Stage 7 — Quality gate (3 skills)

21. copywriting-refiner — audit the full sequence against the quality checklist. Rewrite any failing elements.

22. copywriting-analyzer — score the final copy against lemlist's 244K-campaign benchmark. Surface the score and the top 2 improvement notes to the user.

23. gtm-action-thinker — final challenge pass: "what's the weakest assumption in this campaign? what would break the reply rate?" Surface the answer; rewrite if the user agrees.

    Optional auto-apply (verified live, 2026-05-20): the skill input accepts a gtm_thinker_autoapply: true flag. When set, the orchestrator inspects the critique and applies the strongest mechanical fix automatically — typically dropping a saturated filter value (e.g. currentCompanyLastFundingRoundAt: "Less than 1 month" is inbound-saturated and reduces reply rate), tightening a leaky keyword, or removing a duplicated angle from the sequence. Surface the applied change in the dryrun's gtm_thinker_auto_applied[] array (with the original vs. new payload diff). Default is false — the critique stays advisory unless the user opts in.