
explorium-public-skills
Run B2B data enrichment, prospecting, outbound, and ABM campaigns as Claude Code skills or Codex plugins. Powered by Explorium's real-time data platform and Vibe Prospecting MCP server. Alternative to ZoomInfo, Apollo.io, Clearbit, and Clay for AI agent workflows.
- GitHub stars
- 365
Install
/plugin install explorium-public-skills@explorium-public-skillsRun it inside Claude Code after adding the marketplace with /plugin marketplace add explorium-ai/gtm-skills.
Contents
Discovered from sourceSkills 22
ABM Campaign — DIY Playbook
This skill walks you through a full ABM campaign end-to-end, using Claude Code as the orchestration layer. You bring your ICP definition and credentials; Claude handles the rest.
What you'll build:
- A scored, filtered account list sourced from Vibe Prospecting
- Segment-specific ad creatives (HTML templates + optional Figma assets)
- LinkedIn matched audiences populated with your target accounts
- Live LinkedIn campaigns with personalized ads
- An ongoing monitoring and optimization loop
No personal keys are stored in this skill. You provide credentials at runtime via environment variables or interactive prompts. See setup.md before starting.
Prerequisites
Complete setup.md first. It covers:
- Vibe Prospecting login (
npx @vibeprospecting/vpai@latest) - LinkedIn Ads API credentials
- Figma access token (optional)
Campaign Phases
Phase 1 — Build the Account List
Goal: Translate your ICP into a concrete list of target companies.
Read 01-account-list.md before running any Vibe Prospecting commands.
Quick steps:
- Define your ICP (industry, company size, geography, tech stack, funding stage, intent signals)
- Use
autocompleteto normalize filter values - Fetch matching companies with
fetch-entities(sample 5 first, then full export) - Save to
abm-accounts-raw.csv
# Example: US SaaS companies, 100-1000 employees, using Salesforce
npx @vibeprospecting/vpai@latest autocomplete \
--args '{"field":"linkedin_category","query":"software"}' \
--tool-reasoning 'Building ABM account list for SaaS ICP'
npx @vibeprospecting/vpai@latest fetch-entities \
--args '{
"entity_type": "business",
"filters": {
"linkedin_category": {"values": ["Software Development"]},
"company_headcount_range": {"values": ["101-250","251-500","501-1000"]},
"company_country_code": {"values": ["US"]},
"company_tech_stack_tech": {"values": ["Salesforce"]}
},
"page_size": 5
}' \
--tool-reasoning 'Sample fetch for ABM account list'
Output: abm-accounts-raw.csv
Phase 2 — Enrich & Score the Accounts
Goal: Add firmographic and technographic data, then score and filter to your best-fit accounts.
Read 02-enrich-score.md for scoring model details.
Quick steps:
- Match raw companies to Vibe business IDs
- Enrich with
firmographics,technographics,funding-and-acquisitions - Apply ICP scoring formula (Claude computes a fit score 0–100)
- Filter to accounts above your threshold (suggested: score ≥ 60)
- Save to
abm-accounts-scored.csvandabm-accounts-final.csv
# Match company names to IDs
npx @vibeprospecting/vpai@latest match-business \
--args '{"businesses_to_match": [{"name":"Acme Corp","domain":"acme.com"}]}' \
--tool-reasoning 'Matching accounts for enrichment'
# Enrich firmographics + technographics
npx @vibeprospecting/vpai@latest enrich-business \
--args '{
"business_ids": ["biz_xxx"],
"enrichments": ["firmographics","technographics","funding-and-acquisitions"]
}' \
--tool-reasoning 'Enriching accounts for ABM scoring'
Output: abm-accounts-final.csv (scored, filtered list)
Phase 3 — Create the Ad Templates
Goal: Generate reusable, segment-specific ad templates using Claude Code.
Read 03-ad-templates.md for template structure and design system integration.
Quick steps:
- Define your ad segments (e.g., "Enterprise Fintech", "Mid-Market SaaS", "Startup")
- Specify your design system or brand colors/fonts (or use defaults)
- Claude generates HTML/CSS templates for each LinkedIn ad format:
- Single Image (1200×628 px)
- Carousel cards (1080×1080 px)
- Spotlight ad (300×250 px)
- Templates use placeholders:
{{company_name}},{{company_logo}},{{headline}},{{body_copy}} - Output files saved under
creative/templates/
Tell Claude:
"Create LinkedIn ad templates for these segments: [list]. Use these brand colors: [hex]. Use this value prop: [text]."
Output: creative/templates/<segment>-single.html, creative/templates/<segment>-carousel.html
Phase 4 — Personalize the Creative
Goal: Dynamically update creative elements per account using Figma MCP (or a code-based approach).
Read 04-personalize-figma.md for the Figma MCP workflow and code-based fallback.
Option A — Figma MCP (recommended for polished output):
- Share your Figma design file URL
- Claude reads the template frames via Figma MCP
- For each account, Claude swaps: company logo, company name, segment headline
- Exports PNG assets per account
Option B — Code-based (no Figma):
- Claude uses the HTML templates from Phase 3
- Injects per-account data using a Python/Node script
- Renders to PNG using
puppeteerorplaywright - Saves under
creative/personalized/<company_domain>/
# Install rendering dependencies (Option B)
npm install -g playwright
playwright install chromium
Output: creative/personalized/<company_domain>/<format>.png
Phase 5 — Push Audiences to LinkedIn Ads
Goal: Create a LinkedIn matched audience from your account list and upload company data.
Read 05-linkedin-audiences.md for the full API workflow.
Quick steps:
- Set LinkedIn credentials as environment variables (see
setup.md) - Create a DMP segment (matched audience)
- Upload your company list (domain-based matching — LinkedIn matches ~40–60% of lists)
- Wait for audience to populate (typically 24–48 hours for >300 companies)
# Step 1: Create matched audience
curl -s -X POST "https://api.linkedin.com/v2/dmpSegments" \
-H "Authorization: Bearer $LINKEDIN_ACCESS_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"name": "ABM Target Accounts — Q3 2025",
"accessPolicy": "PRIVATE",
"destinations": [{"destination": "urn:li:sponsoredAccount:'$LINKEDIN_AD_ACCOUNT_ID'"}],
"type": "COMPANY"
}'
# Note the returned segment ID, then upload company list (see 05-linkedin-audiences.md)
Output: LinkedIn DMP Segment ID saved to linkedin-audience-id.txt
Phase 6 — Create & Launch the Campaigns
Goal: Create campaign groups, campaigns, and ad creatives in LinkedIn Campaign Manager.
Read 06-campaign-management.md for full campaign creation and monitoring.
Quick steps:
- Create a campaign group per segment
- Create campaigns targeting your matched audience + segment filters
- Upload personalized creatives as sponsored content
- Set budget, schedule, and bid strategy
- Launch
Monitoring loop (ongoing):
- Claude checks campaign analytics daily
- Flags underperforming ads (CTR < 0.4%, CPC > $15)
- Suggests copy/creative tweaks
- Refreshes audience as new accounts are added
Full Pipeline Checklist
[ ] setup.md — credentials configured
[ ] 01-account-list.md — account list built and exported
[ ] 02-enrich-score.md — accounts enriched, scored, filtered
[ ] 03-ad-templates.md — ad templates created per segment
[ ] 04-personalize-figma.md — creatives personalized per account
[ ] 05-linkedin-audiences.md — matched audience created and populated
[ ] 06-campaign-management.md — campaigns live and monitored
File Outputs Reference
| File | Phase | Description |
|---|---|---|
abm-accounts-raw.csv | 1 | Raw account list from Vibe Prospecting |
abm-accounts-scored.csv | 2 | Accounts with enrichment + fit scores |
abm-accounts-final.csv | 2 | Filtered best-fit accounts (score ≥ threshold) |
creative/templates/ | 3 | HTML/CSS ad templates per segment |
creative/personalized/ | 4 | Per-account rendered ad images |
linkedin-audience-id.txt | 5 | LinkedIn DMP segment ID |
campaign-ids.json | 6 | Campaign group, campaign, creative IDs |
campaign-report.csv | 6 | Daily analytics export |
Troubleshooting
| Problem | Solution |
|---|---|
| Vibe Prospecting auth fails | Run setup from setup.md → Vibe section |
| LinkedIn 401 Unauthorized | Access token expired — re-run OAuth flow in setup.md |
| Audience too small (<300) | Broaden ICP filters in Phase 1; LinkedIn needs 300+ matched companies to serve ads |
| Low audience match rate | Use company domains (not just names) in Phase 5 upload for better matching |
| Figma MCP not available | Use Option B (code-based) in Phase 4 |
| Creatives rejected by LinkedIn | Check LinkedIn ad specs in 03-ad-templates.md |
Account Contact Shortlist
Pull the right people at a target account and rank them for outreach, with a use-case lens (new business, active deal, renewal) and a reachability check.
Input
The user provides:
- A company name or domain (required).
- Optional use case: "prospecting" (default), "deal acceleration", or "renewal" / "expansion".
- Optional seniority focus (C-level, VP+, Director+) or a specific function (sales, marketing, RevOps, security, finance).
- Optional size of the shortlist (default 25, max 100).
Workflow
-
Resolve the company. Match the business from the name or domain. If multiple plausible matches surface, present the top 2 to 3 with industry, size, and HQ, then ask the user to confirm. Sanity-check the resolved firmographics: if a major-brand input comes back as 1-50 employees in a Corporate-Managing-Offices category, the match likely routed to a shell entity. Retry with the alternate domain or the name string before proceeding.
-
Enrich the resolved business with firmographics to anchor the output header (industry, size bucket, revenue bucket, HQ, public vs private).
-
Translate the use case into a persona blueprint before any prospect fetch. Prospecting / default: broad buying-committee coverage across Sales, Marketing, RevOps, IT, and Product, weighted toward Director, VP, and C-level. Deal acceleration: economic buyer plus technical evaluator plus procurement, biased to C-level and VP in the relevant function, plus one Director-level champion. Renewal / expansion: existing product-owner functions plus an executive sponsor, including Manager and Director levels alongside VP+. Intersect any user-supplied seniority or function override with the blueprint and note dropped roles.
-
Discover canonical values for every free-text role or industry token before filtering. Combine a job-title filter with an explicit seniority constraint to keep matches tight: a title-only filter for "Vice President of Engineering" leaks non-VP rows, so intersect title with seniority.
-
Sample 5 prospects scoped to the resolved account, matching the blueprint's titles, seniority, and department, with a reachability proxy (has-email true). Present this preview for the user to sanity-check the persona translation and wait for approval before going full size. When the user names a role rather than a person ("the CFO at Notion"), do not try to resolve a title string as a person; surface candidates via the filtered prospect fetch instead.
-
After approval, materialize the full shortlist and enrich prospects for contact data. Default to email-only contact enrichment because it is the cheaper option; opt in to phone only when the user explicitly needs dialer-ready output. For the top 10, also pull profile enrichment so tenure and prior-role signals can feed the ranking rationale.
-
Rank and group. Score each contact on persona fit (title and department match, weighted by seniority), reachability (professional email, then personal email, then phone), and tenure or stability from the profile pull (recent joiners get a small bump for prospecting, a penalty for renewal). Break ties by seniority.
Output Format
Target Account
One line: company name, domain, industry, headcount bucket, revenue bucket, HQ, public vs private.
Use Case Frame
State the resolved use case and what the shortlist optimizes for (prospecting = buying-committee coverage on a first conversation; deal acceleration = economic buyer plus technical evaluator plus procurement plus a Director-level champion; renewal / expansion = current product owners plus an executive sponsor). List any user-provided overrides that narrowed the blueprint.
Shortlist
| Rank | Full Name | Job Title | Seniority | Department | Professional Email | Phone | Why On The List |
|---|
"Why On The List" is one short clause referencing the persona-blueprint slot the contact fills (e.g. "VP-level economic buyer in Sales"). Show "Unattributed" in the Department column for cross-functional senior roles where department is null.
Coverage Read
Counts by department, by seniority band, and by reachability (professional email, personal email only, phone, none). Flag gaps where the use case expected a slot but no contact was found (e.g. "No procurement contact surfaced for deal acceleration").
Engagement Priority
Pick the top 5 to contact first with a one-line reason each, distinguishing entry points (Manager / Director with strong reachability) from decision makers (VP / CXO in the relevant function). Suggest an outreach order.
Next Steps
- Brief the opener with fresh account context via funding, challenges, or strategic-insights enrichments.
- Fetch prospect events on the shortlist to catch recent role changes or new-hire signals before the first touch.
- Re-run with a different use case to compare the buying committee against an in-flight deal team.
Limitations
- No native contact data-quality sort. Reachability is approximated from the has-email flag plus enriched professional email and phone.
- Headcount and revenue are bucketed, so very narrow size cutoffs are not possible.
- No sub-department job-function filter. The finest cut on function is department plus title.
- The only company-type filter is public vs private. Private subsidiary cannot be distinguished from independent private.
- Department is null for many cross-functional senior roles. Group those under "Unattributed" rather than dropping them.
- Sample previews are capped at 5 rows. Full shortlists materialize only after user approval.
Account Fit Rank
Score and tier a list of accounts on four axes (fit, intent, trigger, workforce) using firmographics, technographics, intent topics, events, and workforce trends, then apply a transparent weighted composite the calling model computes from the returned data.
Input
- Accounts (required): list of business IDs, company names, domains, or a mixed CSV.
- Use case (default
prospecting): one ofprospecting,abm,territory_planning,pipeline_acceleration. Shifts tier thresholds and recommended actions. - ICP definition (required): industries, employee buckets, revenue buckets, country or region, optional tech-stack vendors, optional intent topics. Capture inline; no persisted ICP exists.
- Weight overrides (optional):
{fit, intent, trigger, workforce}summing to 100. Default45 / 25 / 25 / 5. - Tier thresholds (optional):
{A, B}. C is the remainder. DefaultA>=75, B 50-74.
Workflow
-
Lock the ICP and intent topics. Restate the ICP from the user. Discover canonical values for every free-text dimension (industry, technology, intent topic, city). Resolve intent topics one term at a time: fuzzy multi-term queries fail silently. If a tag does not resolve, drop it and flag that axis as configuration-gap, not signal-absent.
-
Resolve identifiers. Route inputs by shape: existing business IDs pass through; domains and names resolve via business match, with an optional country tiebreaker for names. Never silently pick a winner: surface top candidates for ambiguous rows and ask for confirmation. For high-collision names, require domain confirmation before scoring. Sanity-check the resolved firmographics: if a major-brand input returns 1-50 employees and Corporate-Managing-Offices category, the match likely routed to a shell entity. Retry with the alternate domain or the name string. Every input ends as auto-resolved, verified, ambiguous, or failed.
-
Pre-flight relationship context. Tag each resolved account against any user-supplied competitor / customer / partner lists before scoring so a "pursue this competitor" line is never produced silently.
-
Fetch firmographic, technographic, and signal data in small chunks end-to-end (resolve, enrich, score, write row, discard raw payloads). Per chunk: enrich with firmographics, technographics, recent LinkedIn posts, funding and acquisitions, workforce trends, strategic insights, and website changes; then fetch business events scoped to the last 90 days for funding rounds, leadership changes, product launches, and expansions. If the ICP includes intent, size intent-topic exposure separately; if no topics resolved in step 1, set intent weight to zero and redistribute. Drop raw payloads after extracting the per-axis inputs and the single winning signal for "why now".
-
Score each axis (calling model computes from the fetched data):
- Fit (0-100): banded firmographic match. Industry primary = 25, adjacent = 10; employee bucket in band = 20, one off = 12, two off = 4; revenue bucket same banding, max 20; geography country = 15, region = 8; company age in window = 10; vendor match if specified = 10.
- Intent (0-100): 90 for 3+ resolved topics active, 70 for 2, 50 for 1, 0 for none. Record the strongest topic. If no topics resolved, axis = 0 with
configuration-gapand the weight redistributes. - Trigger (0-100):
event_score = type_weight * recency_factor. Type weights: M&A / funding / new CEO = 95; product launch, hiring surge, major website change = 75; partnership, new facility = 55; generic announcement = 25. Recency: 0-14d = 1.0, 14-30d = 0.7, 30-60d = 0.4, 60-90d = 0.2, older = 0. Account trigger = max event_score, capped at 100. Verify the event headline actually mentions the target: industry-wide articles can cross-attribute. - Workforce (0-100): headcount up 10%+ in 90d or target-department hiring surge = 80-100; modest growth = 40-70; flat or shrinking = 10-30; no data = null and the weight redistributes.
-
Composite, tier, and "why now". Composite = round(weighted sum / 100). Cap any axis with no data at null and redistribute proportionally; surface the redistribution. Assign tier from thresholds (use-case overrides:
abmA=80 / B=55,pipeline_accelerationA=65 / B=40). "Why now" is one sentence anchored on the strongest underlying signal, never the composite restated. For strong trigger with low fit, be explicit ("Do not pursue: fresh CEO change but the revenue bucket mismatch keeps this in C."). -
Iterate. Offer: adjust weights and recompute from cached axes; tighten thresholds; drop tier C; swap the ICP; drill into one account with deeper enrichment (challenges, competitive landscape, ratings); add accounts and rescore. Only "add accounts" or "swap ICP" require new calls.
Output Format
TL;DR
Account Fit Rank, N accounts. Use case, weights, thresholds. Resolution counts (resolved / ambiguous / failed; flag if confirmation required). Tier distribution. Top 3 accounts each with a one-line "why now".
Resolution Summary
Table: Input, Resolved To, Business ID, Confidence, Status (auto-resolved, verified, ambiguous, failed). For each ambiguous row, list candidates with industry, headcount, revenue bucket, country and ask the user to pick.
Ranked Accounts
Sorted by composite descending. Use - in any axis column that was redistributed. Columns: #, Account, Tag, Tier, Composite, Fit, Intent, Trigger, Workforce, Why now, Business ID.
Weights and Axes Used
List percentages applied and any axis redistributed because data was unavailable.
Recommended Actions per Tier
Tier A: route to AE for 1:1 outreach within 24h, prioritize contact enrichment. Tier B: SDR sequence using the why-now as opener, retarget for ABM. Tier C: monitor, rescore weekly when fresh events land.
Iteration Options
Adjust weights, tighten thresholds, drop tier C, swap the ICP, drill into one account with deeper enrichment, or add accounts and rescore.
Caveats (when relevant)
Ambiguous-pending count, failed resolutions, intent configuration-gap, stale trigger cliff (60-90d), workforce nulls with weight redistribution.
Limitations
- Business match returns no confidence score; infer ambiguity from candidate-set shape and confirm with the user.
- Strategic-insights and challenges signals come from public filings: null for private companies and 12-18 months stale for public ones. Use events, funding, workforce, and LinkedIn posts for current state.
- No native scoring engine. The composite and tiering are computed by the calling model from the data returned.
- Headcount and revenue are bucketed; band-distance scoring is the right resolution.
- No CRM-engagement axis (deal stage, last activity, named champion); workforce is the substitute, and the gap is surfaced rather than invented.
- Industry taxonomies are mutually exclusive on filters; pick one per run.
- No native similar-companies tool, no metro taxonomy, no Inc / Fortune ranking. Geography is country or region only.
- Country-scoped sizing does not strictly enforce the country filter; read the per-country breakdown rather than the global total.
Account Research
Build a purpose-driven intelligence brief on a single target company, anchored on the user's stated reason for pulling the brief.
Input
- Account identifier (required): a business ID, a company name, or a domain.
- Research context (strongly recommended): one sentence on why this brief is being pulled and what decision it supports (QBR prep, competitive eval vs Acme, cold outbound to finance leaders). This shapes enrichment selection, event triage, and the TL;DR framing.
Example phrasings: "Build a brief on stripe.com for cold outbound to finance leaders.", "Account brief for business_id abc123, QBR next week, watch renewal signals.", "Profile Snowflake, competitive analysis vs Databricks."
Workflow
-
Anchor on purpose. Restate the research context in one sentence as the brief purpose. If missing, ask once; if the user declines, default to general account intelligence and state that assumption. Derive 2 to 4 priority themes (e.g. for QBR renewal risk: workforce changes, exec moves, competing vendors, expansion signals). Themes drive enrichment selection in step 3 and peer-cohort sub-category in step 5.
-
Resolve the company. If a business ID was supplied, use it. Otherwise match the business by name or domain. Sanity-check the resolved firmographics: if a major-brand input returns 1-50 employees and Corporate-Managing-Offices category, the match likely routed to a shell entity. Retry with the alternate domain or the name string before proceeding. If no confident match emerges, surface the ambiguity to the user before continuing rather than guessing.
-
Enrich the resolved business in tiers.
Tier A: spine (always pull): firmographics, hierarchies, funding-and-acquisitions, workforce-trends, linkedin-posts. Plus business events from step 4 (separate tool, same role: current-state signal). The spine is uniform across every brief because each item answers a question the reader will ask regardless of purpose.
Tier B: purpose-conditional (pick by the purpose declared in step 1):
- Competitive eval → technographics, webstack, competitive-landscape
- QBR or renewal → company-ratings, challenges, strategic-insights
- Cold outbound → website-changes, website-keywords (tied to your offering)
- Investor or M&A → financial-metrics
Tier C: skip by default unless the purpose explicitly demands it.
Chunking: run enrichments in groups of at most 3 per call, and each chunk against the original match table rather than a post-enrichment view. Session column count grows per enrichment and the chain breaks around the 4th-5th wide call.
Any tier item that returns null OR is intentionally skipped must surface in the brief as a one-line note inside its section ("Skipped: not in this purpose's bundle" or "Returned null: typical for private companies"), so the reader can distinguish absent data from absent investigation.
-
Fetch business events scoped to the last 90 days: hiring spikes, leadership changes (where surfaced), funding rounds, product launches, layoffs, office moves, tech adoption. For each event, verify the headline actually mentions the target before counting it: industry-wide articles can cross-attribute to multiple companies in the same sector.
-
Build a peer cohort (directional).
5a. Sub-category from purpose, not industry label. A broad industry label (e.g. "Software Development") routes mega-tech defaults like Google or Amazon into a small-tech peer query. Derive the sub-category from the brief purpose instead:
- "vs " → the named competitor's sub-vertical (Databricks → data warehouse / lakehouse)
- "QBR seat-expansion" → the target's collaboration / workflow sub-vertical
- "cold outbound to leaders" → the target's GTM sub-vertical
- General intelligence (no purpose declared) → broad NAICS, marked "general baseline"
5b. Manually include named competitors. If the user prompt named a specific competitor or comparator, include it in the cohort even if filters would exclude it (private status, different size band, different country). Label such rows "named in prompt: manually included" so the reader can audit.
5c. Suppress when thin. If after sub-category filtering and manual additions the cohort still has fewer than 5 confident matches, do NOT render the table. Replace with one line: "Peer cohort suppressed: fewer than 5 confident matches in . Recommend manual comparison against <2-3 named alternatives, tagged verify externally>."
Add a "Cohort construction" line above the table stating the sub-category used and any manually-included names.
-
Reconcile and verify before synthesis.
- Funding recency. If business events show a more recent round than the funding enrichment, treat events as canonical, restate the latest round in the Funding section, and flag the enrichment lag in one line.
- Public-vs-private signal mix. If firmographics returns public, the Funding section must include a one-line financial-posture sentence (ticker, rough market cap band, last reported quarter direction) drawn from general knowledge with a "verify" tag. If private, keep current behavior (events + funding + workforce + LinkedIn as the current-state proxy).
- Per-event cross-attribution. Tag each Recent Events row "target named in headline", "target inferred from body", or "industry-wide: excluded". Excluded items don't appear in the body; list them once at the end of the section as "events screened out (n)". Note any event type the executor expected but couldn't query (e.g. leadership-change) in that same trailer.
- Snapshot fallbacks. For any Company Snapshot row not returned by firmographics (Founded is the typical case), attempt one fallback (LinkedIn posts, website-changes context, general knowledge with verify tag) before leaving blank.
-
Synthesize against the brief purpose. Keep events and signals that map to the purpose, priority themes, or non-obvious flags. Mark past-date enrichments as needing verification. Suppress sections that lack volume: skip funding for public mega-caps (use ticker instead per step 6), flatten challenges or insights to bullets when only 1-3 items. Cross-reference signals (new CTO plus a webstack change plus engineering hiring = a clear timing signal).
-
Write the exec summary last. Re-read the body, then write the TL;DR. The Situation line must explicitly answer "why this brief, now" against the stated purpose.
Output Format
TL;DR: [Company Name]
Brief purpose (restated, or "general account intelligence" if defaulted). Then: Situation (2 to 4 sentences answering "why this brief, now" against the stated purpose), Top 3 facts (most consequential data points), Highest-leverage actions (1 to 3 concrete actions tied to specific signals).
Company Snapshot
A compact field table: Domain, Industry, Headcount bucket, Revenue bucket, HQ Country / Region, Public / Private, Founded, business_id. Any row not returned by firmographics is filled by one fallback per step 6 or marked "not surfaced".
Firmographics & Hierarchy
Firmographics plus parent / subsidiary structure. Note recent restructuring. If hierarchies returned null, state it.
Funding & Capital Structure
Total raised, most recent round date and amount, acquisitions. If business events surfaced a more recent round than the enrichment, lead with the events-side fact and flag the enrichment lag. For public mega-caps, lead with ticker + one-line financial posture per step 6.
Workforce & Hiring Signals
Net headcount change, departmental growth, hiring spikes or contractions. Flag exec moves surfaced via LinkedIn posts or events.
Tech Stack & Website Activity
Tools in use, recent additions or removals, keyword shifts. Highlight items mapping to the user's offering or competitors. If this tier was not pulled for the declared purpose, say so explicitly rather than mislabeling the section.
Challenges & Strategic Insights
Stated pain points, public priorities, expansion plans. Tie back to brief purpose. If null because the target is private, state that and point to the live-signal substitutes (events, funding, workforce, LinkedIn).
Recent Events (last 90 days)
Grouped (Funding / Leadership / Hiring / Product / Risk) when 4+ items span categories, otherwise flat. Each item: event type, date, one-line summary, verified-status per step 6. Call out timing opportunities (new CTO = vendor evaluation likely). End with "events screened out: N (industry-wide cross-attribution)" + any event-type gaps.
Peer Cohort (directional)
First line: "Cohort construction: ; manually included: ." Caveat that the set is approximated from shared sub-category attributes, not exact similarity. Then a top-10 table: Company, Domain, Size, Revenue, Country. If fewer than 5 confident matches survived, suppress the table per step 5c and replace with the recommendation line.
Key Takeaways & Next Steps
3 to 5 bullets connecting dots across sources, framed by the stated purpose. Then concrete next actions tied to specific signals, people, or moments. Omit any line without a concrete target.
Limitations
- Strategic-insights and challenges signals come from public filings: null for private companies and 12-18 months stale for public ones. Use events, funding, workforce, and LinkedIn posts for current state.
- No native similar-companies tool; the peer cohort is approximated from a sub-category derived from the brief purpose and flagged as directional. Named competitors that don't match the filter set are surfaced via the manual-inclusion rule.
- No native intent-topic scoring; intent-style signals come from events, website changes, website keywords, and LinkedIn posts rather than a single ranked feed.
- No AI-generated outbound copy; this skill produces the brief, downstream skills handle messages.
- Bucket-only headcount and revenue. Finer company-type distinctions (subsidiary, JV, PE-backed) must be read from hierarchies and funding rather than filtered.
- Business match returns no confidence score; infer ambiguity from the candidate set, sanity-check the resolved firmographics for shell entities, and confirm with the user when in doubt.
- Event data can cross-attribute industry-wide headlines to multiple companies in the same sector. The per-event verification step is non-optional, not just stylistic.
- No executive-move event type exists; the closest signals are generic hiring and inferred-from-LinkedIn-posts. State this gap in the events trailer when the brief purpose would otherwise expect exec moves.
Browser Extension Builder
Scaffolds a working, local Chrome extension: it detects any LinkedIn profile, shows a floating panel with a "Reveal contact info" button, calls Explorium to return a verified email/phone/job title/company, and lets the user push that contact to HubSpot (with an editable field-mapping review first) or draft a personalized email in Gmail.
Unlike the workflow skills in this repo, which run a prospecting or
enrichment task inside the current Claude Code session, this skill produces a
standalone browser extension loaded via Chrome's "Load unpacked" — a real
artifact the user keeps using, not a one-off list. Reach for enrich-contact
or list-builder when the user wants a contact or list right now; reach for
this skill (or lead-gen-tool-builder) when they want a tool.
No personal keys are stored in this skill. The bundled extension has no
hardcoded credentials — both the Explorium key and the HubSpot token are
pasted into the extension's own Options page at install time and stored in
chrome.storage.local, local to the user's browser profile.
When to use
Trigger this for any request to build a Chrome/browser extension for prospecting or contact discovery, a "Lusha alternative", an "Apollo.io extension clone", a LinkedIn email/phone finder, or a browser tool that reveals contact info and pushes it to a CRM. Example phrasings: "build me a Lusha-style Chrome extension", "clone the Apollo.io browser extension but use our own data", "make a LinkedIn contact finder extension", "I want a browser extension that reveals emails on LinkedIn and pushes to HubSpot".
What you get
The bundled template (assets/lead-finder-extension/) is a ready-to-load
Manifest V3 extension:
- LinkedIn detection — a content script matches
linkedin.com/in/*, waits for the profile to render, and injects a floating panel (avatar, name, headline pulled straight from the page). - Reveal contact info — calls Explorium's
prospects/match→prospects/profiles/bulk_enrich+prospects/contacts_information/ bulk_enrichand renders verified email, phone, job title, company, company website, and location with a "Verified by Explorium" badge. - Push to HubSpot — an editable review step (first/last name, email, job title, company, phone) before a search-then-create-or-update call to HubSpot's Contacts API, so re-pushing the same person updates instead of duplicating.
- Draft email — opens a prefilled Gmail compose tab built from the enriched name/company/title.
- Options page for pasting the Explorium key and HubSpot token; a toolbar popup with status text and a link to Options.
Workflow
1. Copy the template into the user's workspace
cp -R "<this-skill-dir>/assets/lead-finder-extension" ./lead-finder-extension
Don't copy node_modules or build artifacts — there are none; this is a
vanilla, dependency-free MV3 extension (no build step at all).
2. Get API keys
Only Explorium is required to reveal contacts; HubSpot is optional and only
needed for the push button. Summarize from assets/lead-finder-extension/ README.md:
- Explorium (required): sign up at developers.explorium.ai → API Keys.
Do not confuse this with Vibe Prospecting — Vibe Prospecting
(
vibeprospecting.explorium.ai) is a separate, OAuth-only MCP server for prospecting inside an agent session; it issues no static API key and cannot be pasted into a browser extension. This skill always needs the classic REST API key. - HubSpot (optional): Settings → Integrations → Private Apps → create an
app with
crm.objects.contacts.write(+.readfor the dedup lookup).
3. Load it and configure keys
# Chrome -> chrome://extensions -> enable Developer mode -> Load unpacked
# -> select the lead-finder-extension folder
Click the toolbar icon → Set API keys → paste the Explorium key and (if using CRM push) the HubSpot token → Save.
4. Verify
Open a real linkedin.com/in/... profile — the panel should appear top-right
within a couple of seconds. Click Reveal contact info and confirm real
data comes back. If HubSpot is configured, push a contact and confirm the
success toast, then check the contact exists in HubSpot.
After any code change: reload the extension's card in chrome://extensions,
then hard-refresh the LinkedIn tab — Chrome does not re-inject content
scripts into tabs that were already open.
Architecture
background.js— the MV3 service worker; the only place API keys are ever read fromchrome.storage.local. Owns allfetch()calls toapi.explorium.aiandapi.hubapi.com, and message-routesLEADFINDER_REVEAL/LEADFINDER_PUSH_HUBSPOT/LEADFINDER_OPEN_TAB.content.js— injected onlinkedin.com/in/*. Scrapes name/headline/ photo from the page as an instant preview, renders the panel's state machine (reveal → loading → result → HubSpot field-mapping review), and never touches an API key directly — it only messages the background worker.styles/tokens.css— the entire visual identity as CSS variables (--leadfinder-primary,--leadfinder-ink, radii, shadows, font stack).content.css,popup.html, andoptions.htmlall consume these tokens rather than hardcoding colors.manifest.json— noteweb_accessible_resourcesfor the icon PNGs. MV3 blocks a content script from loading extension assets (like the toolbar icon shown inside the injected panel) unless they're explicitly declared there — easy to forget and the failure mode is a silently broken<img>in the panel.
Customizing / restyling to match a brand
This is the most common follow-up request: "make it look like Lusha", "use Apollo.io's design system", "give it a HubSpot-native look". Do this:
- Research the real brand before guessing. Web search and generic
knowledge about a company's colors are frequently wrong (a blue-brand
guess for a company that's actually lime-green is a realistic failure
mode). The most reliable signal is the company's own favicon or Chrome
extension icon — fetch it directly and read the pixel colors:
Cross-check against the target's Chrome Web Store listing and any "brand/visual identity" blog posts before finalizing a palette.curl -sL <https://company.com/favicon.ico> -o /tmp/favicon.ico python3 -c " from PIL import Image img = Image.open('/tmp/favicon.ico').convert('RGBA') print('corner (bg):', img.getpixel((2, 2))) print('center (mark):', img.getpixel((img.width//2, img.height//2))) " - Update
styles/tokens.csswith the real hex values — rename the token if its semantics changed (e.g.--leadfinder-primarystaying "primary" is fine; don't leave a token named-limeholding a blue hex). - Regenerate the icon to match the brand's mark. For a simple geometric
shape, hand-write the SVG. For anything more organic, generate it with an
image model and composite it onto an exact-hex background with Pillow so
the brand color is pixel-accurate rather than whatever the model
approximated:
Then rasterize all four sizes withfrom PIL import Image, ImageDraw bg = Image.new("RGBA", (128, 128), (0, 0, 0, 0)) ImageDraw.Draw(bg).rounded_rectangle([0, 0, 127, 127], radius=18, fill=(R, G, B, 255)) mark = Image.open("generated_mark.png").convert("RGBA").resize((92, 92)) bg.alpha_composite(mark, (18, 18))rsvg-convert(if you kept an SVG source) or export directly from the composite. - Rename display strings (
manifest.jsonname, popup/options headers, the panel title incontent.js) — leave theleadfinder-CSS/JS class prefix alone unless the user asks for a full fork/rename, since renaming it everywhere is mechanical but easy to half-do and break a selector. - Show the result before calling it done. Render the popup, options
page, and result panel as standalone HTML files against
styles/ tokens.css+content.cssin a browser preview, and look at the screenshot yourself — don't assume a hex swap looks right. - Never reproduce a trademarked logo pixel-for-pixel if the resulting
extension will be shared or published anywhere beyond the requester's own
local machine — recreate the style (color, shape language, motion
weight), not a copy of the asset itself. This matters more once the
output leaves a single person's local
chrome://extensionspage.
Limitations
- LinkedIn's DOM changes over time;
content.jspolls for the profile<h1>(up to ~6s) rather than assuming a fixed load time, but exact CSS selectors may need updating if LinkedIn changes its markup. - HubSpot auth is a private-app token (simple, but scoped to one HubSpot account) — there's no OAuth flow, so this isn't a multi-tenant install.
- This produces a local, unpacked extension for personal/team use, not a Chrome Web Store submission — there's no review-ready packaging, privacy policy, or store listing here.
- Vibe Prospecting cannot power this extension's reveal step (see above) — only a classic Explorium REST API key works.
Clean Data
Per-row cleanup on a GTM list before any match or enrich call. Profile, standardize, validate. Never destructive: raw input is preserved, invalid rows are tagged with reason codes rather than deleted. Out of scope: deduplication and canonical entity resolution.
Input
$ARGUMENTS is a path to a CSV, Excel, or JSON file. Parse the user message for optional sub-inputs:
- Schema hints if column names are ambiguous: which column is company name, domain, email, phone, country.
- Entity type: companies, contacts, or both. Default: infer from columns.
- Whether to run an MX-record check on email domains (slower, requires DNS). Default: off.
- Whether to produce a match-ready subset for downstream entity resolution. Default: no.
Example phrasings:
- "Clean this leads CSV before I import it to HubSpot."
- "Normalize the company names and domains in /path/accounts.xlsx."
- "Validate the emails in this file and tag the bad rows."
- "Prep this list for prospect matching, only keep contactable corporate rows."
- "Why does my country column have 200 different spellings."
Workflow
-
Copy raw input. Before any transform, copy the input to
./00_raw/<filename>and never write back. All transforms write to numbered phase folders:01_profiled/,02_standardized/,03_validated/. The single most common failure mode in cleanup work is destructive transforms with no path back. -
Profile the file. Compute fill rate, cardinality, top values, length distribution, and format-pattern frequency for every column. Save the snapshot. Read it before deciding what to clean.
import pandas as pd df = pd.read_csv(input_path) profile = pd.DataFrame({ "fill_rate_pct": (df.notna().mean() * 100).round(1), "cardinality": df.nunique(), "top_value": df.apply(lambda c: c.dropna().astype(str).mode().iloc[0] if c.dropna().size else None), "avg_len": df.apply(lambda c: c.dropna().astype(str).str.len().mean()), })Things to look for: country columns with 200+ distinct values (standardization problem, build ISO Alpha-2 lookup); phone columns where under 50% parse as E.164 (need country hint); company-name 99th-percentile length above 100 chars (pasted addresses, quarantine); free-email providers in the top 5 of email column (decide policy now); fields under 10% fill (probably not worth normalizing); literal strings
"NA","N/A","None","null","-"(collapse to real nulls before validating). -
Standardize string fields. Run standardization BEFORE validation: a valid email like
JOHN@ACME.COMfails naive regex without trim+lowercase first. For every string column do Unicode NFKC, trim, collapse internal whitespace, strip leading and trailing punctuation, collapse null-token strings to real nulls. Then field-specific:- Company name. Strip legal suffixes (
Inc,LLC,Ltd,GmbH,S.A.,株式会社) at end of string only. Usecleancoif available. Keep BOTH raw and normalized columns. - Domain. Strip protocol and
www. Fold to the eTLD+1 viatldextract. Flag free-email providers and disposable domains separately. - Person name. Parse with
nameparser: honorifics, generational suffixes, credentials, particles. If confidence is low, store the raw string with a low-confidence flag. - Phone. Format to E.164 with
phonenumbers. Hint country from the country column when available. - Country. Map free-text to ISO Alpha-2 codes (
United StatestoUS,UKtoGB,DeutschlandtoDE). Reusable downstream for country filters. - Address. Use
libpostalif installed. Country-aware parsing.
Common mistake: overwriting the display column with the normalized version. Always keep raw alongside normalized.
- Company name. Strip legal suffixes (
-
Validate field-by-field. Per field, add a boolean
<field>_validand a<field>_reasontext column when invalid. Tag invalid rows; never delete them.- Emails: RFC 5322 syntax via
email-validator; role-address detection (info@,sales@,noreply@,support@,hello@); disposable-domain check; free-provider flag (gmail,yahoo,qq); optional MX-record check (off by default). - Phones: parse + format via
phonenumbers. Taginvalid_too_short,invalid_country,invalid_format. - Domains: valid eTLD, no IP literals, optional MX check.
- Country codes: valid ISO Alpha-2 after normalization.
- Emails: RFC 5322 syntax via
-
Hand off to entity resolution (optional). This skill cleans rows in isolation; it cannot tell you that
Starbucks EMEAandStarbucks Corporationpoint to the same company. If the user wants the handoff, produce a match-ready subset and route rows by available signal:- Rows with normalized company name + domain: route to match a business (name + website, falls back to domain-only on mismatch).
- Rows with a corporate (not role / free-provider / disposable) email: route to match a prospect via email.
- Rows with parsed person name + company name: route to match a prospect via name + company.
- Rows with a validated LinkedIn URL: route to match a prospect via LinkedIn.
Filter out tagged-invalid rows before the handoff so you do not spend credits matching
noreply@example.comor disposable addresses. The returned IDs become the join keys for any later enrich a business or enrich a prospect call.
Output Format
Profile Snapshot
Per column: fill_rate_pct, cardinality, top_value, avg_len. Markdown table. After cleanup, re-run the profile and show before vs after on touched columns.
Standardization Map
Per normalized field: raw column name, normalized column name, 3 to 5 example transformations (" ACME, Inc. " to acme, "WWW.Acme.COM" to acme.com, "+1 (415) 555 1212" to +14155551212).
Validation Verdict
Per validated field: counts of valid, invalid, risky. Frequency table of reason codes (e.g. role_address: 42, disposable_domain: 18, invalid_syntax: 6).
Cleaned File
A single CSV at ./03_validated/<input_name>_clean.csv with all original columns plus <field>_norm, <field>_valid, and <field>_reason columns.
Match-Ready Subset (only if requested)
A second CSV at ./04_match_ready/<input_name>_for_match.csv containing only rows that passed validation, plus a one-line summary of which match path each row subset should route to (count by path).
Limitations
- Does NOT deduplicate or resolve to canonical entities. Two normalized strings can still refer to the same real-world business. Hand off to a match step for that.
- Person-name parsing is best-effort. Non-Western order, hyphenated families, and missing separators are flagged with a low-confidence marker; raw string is always preserved.
- The MX-record check requires DNS and adds 50 to 200ms per unique domain. Off by default.
- Free-email providers (gmail, yahoo) are flagged but cannot be linked to a corporate identity from this skill alone. Pair with a prospect match (email + company) when needed.
- Holding-company and subsidiary pitfalls are out of scope (
meta.comvsinstagram.comvswhatsapp.com). Resolve via company-hierarchies enrichment after matching. - If the input lacks a country column entirely, phone normalization defaults to a permissive parser and may mis-format short numbers. Provide a default country in the user message when possible.
Cold Email — Vibe Prospecting + Lemlist
Build a targeted prospect list, enrich it with firmographic and contact data, have Claude write personalized emails for each prospect, and push everything to a live Lemlist campaign — ready to send.
What you'll end up with:
- A filtered, enriched prospect list with verified work emails
- A personalized first-line (icebreaker) and full email per prospect, written by Claude using their actual company data
- All leads uploaded to a Lemlist campaign with personalization variables pre-filled
Step 0 — Credential Check (Claude: always do this first)
Do not start Phase 1 until both checks pass.
Vibe Prospecting
Cowork mode: look for a tool matching mcp__*__fetch-entities in your tool list.
- ✅ Found → proceed
- ❌ Missing → tell the user: "Please connect the Vibe Prospecting connector from the connector store, then let me know when it's done." Wait. Do not continue until the tool appears.
Claude Code / terminal:
npx @vibeprospecting/vpai@latest --help
- ✅ Lists tools → proceed
- ❌ Error → run:
npx @vibeprospecting/vpai@latest config --api-key "YOUR_VP_API_KEY"
Lemlist API Key
Ask the user: "Please paste your Lemlist API key. I'll verify it and we'll get started."
Get it from: Lemlist → Settings → Integrations → API.
Once provided, verify:
export LEMLIST_API_KEY="<key-from-user>"
curl -s "https://api.lemlist.com/api/team" \
-u ":$LEMLIST_API_KEY" \
| python3 -c "
import json, sys
d = json.load(sys.stdin)
print('✅ Connected —', d.get('name', 'team found')) if '_id' in d else print('❌ Failed:', d.get('message', 'unknown error'))
"
- ✅ Connected → tell the user "Both credentials verified — let's go." Proceed to Phase 1.
- ❌ Failed → ask the user to check the API key in Lemlist → Settings → Integrations → API. Do not proceed.
Phase 1 — Define Your ICP and Fetch Prospects
Ask the user for their targeting criteria if not already provided:
"Who are we targeting? Tell me: industry, company size, geography, job titles/levels, and any tech stack or funding signals you want to filter on."
Then run autocomplete for any controlled-vocab fields before fetching.
# Normalize industry/category values first
npx @vibeprospecting/vpai@latest autocomplete \
--args '{"field": "linkedin_category", "query": "<user industry>"}' \
--tool-reasoning 'Normalize industry filter for cold email prospect list'
# Normalize job titles if needed
npx @vibeprospecting/vpai@latest autocomplete \
--args '{"field": "job_title", "query": "<user job title>"}' \
--tool-reasoning 'Normalize job title for cold email prospect list'
Sample 5 prospects first (full chain — do not stop after fetch to ask for approval):
npx @vibeprospecting/vpai@latest fetch-entities --all-parameters
npx @vibeprospecting/vpai@latest fetch-entities \
--args '{
"entity_type": "prospects",
"filters": {
"job_level": {"values": ["<user levels>"]},
"job_department": {"values": ["<user departments>"]},
"linkedin_category": {"values": ["<normalized category>"]},
"company_headcount_range": {"values": ["<user size range>"]},
"company_country_code": {"values": ["<user geo>"]},
"has_email": true
}
}' \
--number-of-results 5 \
--tool-reasoning '<user request verbatim>'
Note the session_id and table_name from the output — pass these to every subsequent step.
Run the full enrich chain on those 5 (Phase 2), show the result as a table, then ask: "Does this look right? How many prospects do you want in the full run?" Only after approval re-run at full scale.
Phase 2 — Enrich with Contact Info
Enrich the fetched prospects with verified work email, LinkedIn URL, and direct phone.
npx @vibeprospecting/vpai@latest enrich-prospects --all-parameters
npx @vibeprospecting/vpai@latest enrich-prospects \
--args '{"enrichments": ["contacts", "profiles"]}' \
--session-id <SESSION_ID> \
--table-name <TABLE_NAME_FROM_FETCH_STEP> \
--tool-reasoning '<user request verbatim>' \
--csv
Drop any prospects where work_email is empty — Lemlist requires a valid email to add a lead.
Output: prospects-enriched.csv — columns include first_name, last_name, work_email, linkedin_url, job_title, company_name, company_domain, employee_count, annual_revenue, tech_stack, last_funding_type
Phase 3 — Write Personalized Emails
Read prospects-enriched.csv and write a personalized email for each prospect using their actual company data. Do not use generic templates — each email should reference something specific to that company.
Ask the user for:
"What's the core value prop you want to lead with? And is there a specific pain point, use case, or trigger (e.g. recent funding, tech stack) you want to reference?"
For each prospect, write:
1. Icebreaker (1 sentence) — a specific, researched opening line referencing something real about their company. Examples of what to use:
- Their tech stack (e.g. "Noticed you're running Salesforce + HubSpot...")
- Company size/growth signal (e.g. "With [X] employees and growing...")
- Funding event (e.g. "Congrats on the Series B — scaling RevOps is usually top of mind at that stage...")
- Industry-specific angle
2. Email body — 4–6 sentences max. Structure:
- Icebreaker (from above)
- One-sentence value prop tied to their context
- One-sentence social proof or specific outcome
- Clear, low-friction CTA (e.g. "Worth a 15-min call this week?")
3. Subject line — short, specific, not salesy. Under 8 words.
Write all output to prospects-emails.csv, adding these columns to the enriched data:
| Column | Description |
|---|---|
icebreaker | Personalized first line |
email_subject | Subject line |
email_body | Full email body |
Example output row:
| Field | Value |
|---|---|
icebreaker | Noticed you're running Salesforce and recently closed a Series A — congrats. |
email_subject | faster pipeline data for [company] |
email_body | Noticed you're running Salesforce and recently closed a Series A — congrats. At that stage, RevOps teams usually hit a wall with stale CRM data slowing down outbound. Explorium helps teams like yours enrich and score their entire HubSpot or Salesforce account base in under an hour, so reps are always working the right accounts. Happy to show you a quick example with your actual ICP. Worth a 15-min call this week? |
After writing all emails, show a table of 3–5 sample rows for the user to review before uploading. Ask: "Does the tone and personalization feel right? Any tweaks before I push to Lemlist?"
Phase 4 — Create Lemlist Campaign
Create a new campaign in Lemlist to hold these prospects, or ask the user if they want to add to an existing one.
Option A — Create a new campaign
# Create campaign
CAMPAIGN=$(curl -s -X POST "https://api.lemlist.com/api/campaigns" \
-u ":$LEMLIST_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"name": "Vibe Prospecting — <ICP description> — <date>",
"type": "email"
}')
echo $CAMPAIGN | python3 -c "import json,sys; d=json.load(sys.stdin); print('Campaign ID:', d.get('_id','error'))"
export LEMLIST_CAMPAIGN_ID="<campaign _id from above>"
Option B — Use an existing campaign
# List existing campaigns
curl -s "https://api.lemlist.com/api/campaigns" \
-u ":$LEMLIST_API_KEY" \
| python3 -c "
import json, sys
for c in json.load(sys.stdin):
print(c['_id'], '—', c['name'])
"
# User picks one → set it
export LEMLIST_CAMPAIGN_ID="<chosen campaign id>"
Phase 5 — Upload Leads to Lemlist
Add each prospect from prospects-emails.csv to the campaign. Lemlist accepts custom variables per lead — use these to carry the personalized icebreaker and email copy into the campaign.
import csv, json, os, requests, time
API_KEY = os.environ["LEMLIST_API_KEY"]
CAMPAIGN_ID = os.environ["LEMLIST_CAMPAIGN_ID"]
AUTH = ("", API_KEY)
with open("prospects-emails.csv") as f:
prospects = list(csv.DictReader(f))
success, failed = 0, []
for p in prospects:
email = p.get("work_email", "").strip()
if not email:
continue
payload = {
"firstName": p.get("first_name", ""),
"lastName": p.get("last_name", ""),
"companyName": p.get("company_name", ""),
"linkedinUrl": p.get("linkedin_url", ""),
# Custom variables — reference these in your Lemlist email template
# as {{icebreaker}}, {{emailBody}}, {{emailSubject}}
"icebreaker": p.get("icebreaker", ""),
"emailBody": p.get("email_body", ""),
"emailSubject": p.get("email_subject", ""),
}
resp = requests.post(
f"https://api.lemlist.com/api/campaigns/{CAMPAIGN_ID}/leads/{email}",
auth=AUTH,
json=payload
)
if resp.status_code in (200, 201):
success += 1
elif resp.status_code == 429:
print("Rate limited — waiting 5s")
time.sleep(5)
resp = requests.post(
f"https://api.lemlist.com/api/campaigns/{CAMPAIGN_ID}/leads/{email}",
auth=AUTH, json=payload
)
if resp.status_code in (200, 201):
success += 1
else:
failed.append({"email": email, "error": resp.text})
else:
failed.append({"email": email, "error": resp.text})
print(f"\n✅ {success} leads uploaded")
if failed:
print(f"❌ {len(failed)} failed:")
for f in failed: print(" ", f["email"], "—", f["error"])
After upload, tell the user:
"[N] leads are now in your Lemlist campaign. Before you launch, make sure your email template in Lemlist uses
{{icebreaker}},{{emailBody}}, and{{emailSubject}}as variables so the personalization populates correctly. You'll also want to set your sending schedule and daily limits in Lemlist before activating."
Full Checklist
[ ] Step 0 — Vibe Prospecting connected, Lemlist API key verified
[ ] Phase 1 — ICP defined, prospect list fetched (sample approved)
[ ] Phase 2 — Prospects enriched with verified emails and company data
[ ] Phase 3 — Personalized emails written and reviewed
[ ] Phase 4 — Lemlist campaign created or selected
[ ] Phase 5 — Leads uploaded with personalization variables
[ ] Done — Review campaign in Lemlist, set schedule, activate
Lemlist Template Setup (one-time)
In your Lemlist campaign, your email step should use these variable placeholders:
Subject: {{emailSubject}}
{{icebreaker}}
{{emailBody}}
This lets Claude's personalized copy flow directly into each lead's email without any manual editing.
Troubleshooting
| Problem | Solution |
|---|---|
| Vibe Prospecting tools missing | Connect from connector store; wait for mcp__*__fetch-entities to appear |
| Lemlist 401 Unauthorized | API key wrong — regenerate in Lemlist → Settings → Integrations → API |
| Lemlist 404 on lead upload | Campaign ID is wrong — re-check with the list campaigns call in Phase 4 |
| Lead already exists error | Lemlist returns 409 if the email is already in the campaign — safe to ignore |
| Low match rate / missing emails | has_email: true filter in Phase 1 ensures only contactable prospects are fetched |
| Emails feel generic | Give Claude more context in Phase 3: specific pain points, recent company news, or competitor context |
| Lemlist rate limits | API allows ~120 req/min — the script handles 429s with retry; for very large lists add time.sleep(0.5) between calls |
Competitor Research
Produce a dated, source-tagged competitive brief for one or more named rival companies.
Input
- One or more competitor company names or domains (required).
- Optional brief purpose (e.g. "battlecard for renewal", "board update", "win-loss prep"). If absent, ask once before running so the synthesis stays grounded.
- Optional priority angles (e.g. "pricing pressure", "AI roadmap", "EMEA expansion").
- Optional named hypotheses to confirm or contradict.
Workflow
-
Anchor on purpose. Restate the brief purpose, priority angles, and hypotheses in 1-2 sentences before any tool call so synthesis stays scoped.
-
Resolve each competitor: match a business by name + domain when available. Domain-variant sanity check: if a major-brand input resolves to a tiny headcount with a "Corporate Managing Offices" or "Hotels and motels" classification, the match likely routed to a registered-agent shell entity. Re-try with the alternate domain or with the company-name string. Do not proceed with the wrong identity. Skip any name that does not resolve confidently and flag it under data quality.
-
Enrich each resolved competitor across these dimensions: firmographics (HQ, headcount, revenue, founded), competitive landscape (named competitors), strategic insights (priorities and recent moves), funding and acquisitions (rounds and M&A), workforce trends (headcount trajectory), technographics (current stack), challenges (publicly surfaced risks), company ratings (third-party signals), and LinkedIn posts (recent owned-channel narrative).
-
Fetch business events for the resolved set, scoped to the last 90 days. Keep events that map to: product launches, leadership changes at vice president and above, funding rounds, M&A, office openings or closures, and material hiring shifts. Discard the rest. Event-attribution sanity check: before including any event row in the brief, verify the event title or snippet actually mentions the target company. Industry-wide articles can be cross-attributed to multiple competitors' identities in the ingestion pipeline.
-
Surface the executive team per competitor: size the audience first (count of C-level and VP roles per company), then sample a small slice for preview. Run a count before any larger pull so you can frame the sample honestly.
-
If the user asks for outreach-ready contacts on a specific exec subset, enrich those prospects with contacts and profiles. Default to email-only contacts: it costs less than email + phone, and phone numbers are only needed for SDR dialer flows. Use presence-of-email as the contact-quality proxy when filtering.
-
Classify ICP overlap per competitor (High / Partial / None) using firmographics versus the user's stated ICP. If no ICP was stated, mark overlap as "Not assessed" rather than guessing.
-
Address each named hypothesis explicitly as confirmed, contradicted, or unresolved, citing the specific enrichment or event row that drove the call.
-
Final delivery: write the working table out only as the last step (exec roster + key firmographic columns); keep all intermediate previews on screen.
Output Format
Executive Comparison
- Purpose statement (one sentence) and hypothesis check (confirmed / contradicted / unresolved per item).
- Side-by-side table across all resolved competitors with columns: company name, domain, HQ, headcount, size bucket, revenue bucket, founded year, public/private, CEO or top exec, last funding event, last strategic move (dated), competitive products noted.
- 90-day move highlights: dated bullets per competitor, source-tagged to the enrichment that surfaced them (strategic insights, funding, business events).
- Data quality flags: unresolved names, empty enrichments, stale records, contradictions between enrichments.
Per-Competitor Section
Repeat per resolved competitor:
- Snapshot: HQ, headcount, revenue range, founded, public/private, primary tech-stack signals.
- Recent moves (last 90 days): dated bullets, each tagged with the enrichment source.
- Strategic positioning: pulled verbatim from strategic-insights and competitive-landscape where present. Do not paraphrase.
- Workforce trajectory: direction and magnitude.
- Challenges: bullets, dated where available.
- Funding and M&A: latest round, investors, any acquisitions or divestitures.
- Exec roster preview: sampled rows with full name, job title, LinkedIn URL, professional email (if enriched). Frame as "Sample preview (5 of matches)." If totals were not captured, use "Sample preview (5 rows). Many more match these filters."
- ICP overlap: High / Partial / None / Not assessed, with the firmographic evidence in one line.
- Three discovery questions rooted in specific surfaced facts (not generic).
Limitations
- Strategic-insights and challenges are gated on SEC 10-K filings: populated for public competitors, null for private ones, and can be 12-18 months stale even when present. Use NAICS + LinkedIn category + technographics overlap for private targets.
- No native sort by employee count, revenue, or contact data quality. Contact quality is approximated by presence-of-email.
- Employee count and revenue are bucketed, not raw integers. Side-by-side comparisons use bucket labels.
- No similar-companies tool. For adjacent rivals beyond named inputs, approximate by resolving competitive-landscape outputs and re-enriching them, and flag the approach explicitly.
- No metropolitan-area taxonomy. Geographic comparisons use country (ISO-2) or region (ISO 3166-2).
- Only public/private as a company-type filter; finer ownership structure is not available.
- Sentiment from G2, TrustRadius, or earnings transcripts is not in the data surface and is out of scope.
Contact Research — Vibe Prospecting Deep Profile
Given a list of people, match and enrich each one with Vibe Prospecting, then have Claude write a professional synopsis — who they are, what they do, their career trajectory, and what's relevant to know before engaging with them.
What you'll end up with:
- Verified contact info (work email, LinkedIn, direct phone) for each person
- A full professional profile: current role, work history, seniority, department, company context
- Recent career signals: job changes, promotions
- A 4–6 sentence professional synopsis per person, written by Claude in plain English
Good for: pre-call research, account intelligence, investor diligence on founders, recruiting, conference prep.
Step 0 — Credential Check (Claude: always do this first)
Cowork mode: confirm mcp__*__fetch-entities is in your tool list.
- ✅ Found → proceed
- ❌ Missing → tell the user: "Please connect the Vibe Prospecting connector from the connector store, then let me know." Wait. Do not continue.
Claude Code / terminal:
npx @vibeprospecting/vpai@latest --help
- ✅ Lists tools → proceed
- ❌ Error → run:
npx @vibeprospecting/vpai@latest config --api-key "YOUR_VP_API_KEY"
Phase 1 — Prepare Your People List
Ask the user how they want to provide their list:
"How would you like to provide the people? You can: (A) paste names and companies directly in chat, (B) share a CSV file, or (C) describe who you're targeting and I'll find them from Vibe Prospecting's database."
Option A — Paste in chat
Claude converts the input into a structured CSV. Minimum needed per person: full_name + one of company_name, email, or linkedin.
Option B — CSV file
Accepted columns (use whatever you have — more is better for matching):
| Column | Description |
|---|---|
full_name | Full name (or first_name + last_name separately) |
email | Work or personal email |
linkedin | LinkedIn profile URL |
company_name | Current company name |
business_id | Vibe Prospecting business ID (skip match step if you have this) |
Save the file as people-input.csv.
Option C — Find them from scratch
If the user describes a persona (e.g. "CFOs at fintech companies in the US"), use fetch-entities with entity_type: prospects to build the list, then proceed from Phase 2. Sample 5 first before scaling.
npx @vibeprospecting/vpai@latest fetch-entities \
--args '{
"entity_type": "prospects",
"filters": {
"job_level": {"values": ["c_suite"]},
"job_department": {"values": ["finance"]},
"linkedin_category": {"values": ["Financial Services"]},
"company_country_code": {"values": ["US"]},
"has_email": true
}
}' \
--number-of-results 5 \
--tool-reasoning '<user request verbatim>'
Phase 2 — Match to Vibe Prospecting IDs
Resolve each person to an Explorium prospect ID. This unlocks all downstream enrichment.
npx @vibeprospecting/vpai@latest match-prospects --all-parameters
# From CSV
npx @vibeprospecting/vpai@latest match-prospects \
--file-path people-input.csv \
--schema '{"full_name":"full_name","email":"email","linkedin":"linkedin","company_name":"company_name"}' \
--tool-reasoning 'Match people list for deep contact research'
Note the session_id and table_name from the output.
On low match confidence: drop records with confidence < 0.7 and flag them for the user — they may need a cleaner input (e.g. adding LinkedIn URL or email helps significantly).
Phase 3 — Enrich Profiles and Contact Info
Pull the full professional profile for each matched person, plus their verified contact details.
npx @vibeprospecting/vpai@latest enrich-prospects --all-parameters
npx @vibeprospecting/vpai@latest enrich-prospects \
--args '{
"enrichments": ["contacts", "profiles"]
}' \
--session-id <SESSION_ID> \
--table-name <TABLE_NAME_FROM_MATCH_STEP> \
--tool-reasoning 'Enrich profiles and contact info for research' \
--csv
What "profiles" gives you:
- Current job title, department, seniority level
- Full work history (company, title, dates)
- Education history
- LinkedIn URL
- Skills and areas of expertise
What "contacts" gives you:
- Verified work email
- Direct phone / mobile (when available)
- LinkedIn URL (confirmed)
Phase 4 — Fetch Career Signals
Pull recent career events for each person — job changes and promotions are the most useful signals for understanding where someone is and why they might be receptive to a conversation.
npx @vibeprospecting/vpai@latest fetch-prospects-events --all-parameters
npx @vibeprospecting/vpai@latest fetch-prospects-events \
--args '{
"event_types": ["job_change", "promotion"],
"timestamp_from": "<12 months ago, format YYYY-MM-DD>"
}' \
--session-id <SESSION_ID> \
--table-name <TABLE_NAME_FROM_ENRICH_STEP> \
--tool-reasoning 'Fetch career events for contact research' \
--csv
Save the combined enriched + events data as people-enriched.csv.
Phase 5 — Write Professional Synopses
Read people-enriched.csv and write a professional brief for each person. Each synopsis should be in plain, natural English — like a colleague briefing you before a meeting, not a LinkedIn bio.
For each person, write a 4–6 sentence synopsis covering:
- Who they are right now — current role, company, seniority. What they're responsible for.
- How they got here — 1–2 relevant prior roles that show their trajectory or expertise.
- What they know — domain expertise, industries they've worked in, notable skills or patterns across their career.
- What's changed recently — any job change or promotion in the last 12 months. If nothing changed, note their tenure in the current role.
- What's worth knowing — one insight that would be useful before engaging: a shared background, a relevant company pivot, a pattern in their career, or a company context signal (e.g. their company just raised, or is in a growth stage).
Tone: confident, specific, no filler. Avoid phrases like "passionate about", "seasoned professional", or "proven track record." Use the actual data.
Example synopsis:
Sarah Chen is the VP of Revenue Operations at Lattice, where she owns the full RevOps stack — CRM, pipeline reporting, territory planning, and sales tool evaluation. Before Lattice she spent four years at Salesforce, first as a sales ops analyst and then as a senior manager, which explains her strong bias toward CRM-native workflows. Her career has stayed tightly in the revenue/GTM ops lane, moving from execution roles into leadership over the last three years. She joined Lattice 14 months ago, likely as part of a post-Series D scaling push. Worth knowing: Lattice runs HubSpot, not Salesforce — so she made a deliberate switch when she moved, which suggests she's not locked into any one platform.
Phase 6 — Deliver the Output
Present results in two formats:
1. In-chat briefing (for small lists, ≤ 10 people)
Show each person as a card:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
👤 [Full Name] — [Title] at [Company]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📧 [work_email]
🔗 [linkedin_url]
📱 [phone if available]
[Synopsis paragraph]
Career signals: [any job change/promotion in last 12 months, or "No recent changes — [X] years in current role"]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
2. CSV export (for larger lists or when the user wants to save/share)
Write people-research.csv with columns:
| Column | Description |
|---|---|
full_name | Full name |
job_title | Current title |
company_name | Current company |
work_email | Verified work email |
linkedin_url | LinkedIn URL |
phone | Direct phone (if available) |
synopsis | Claude's professional synopsis |
career_signal | Most recent job change or promotion (if any, last 12 months) |
years_in_role | Approximate tenure in current role |
Full Checklist
[ ] Step 0 — Vibe Prospecting connected
[ ] Phase 1 — People list prepared (pasted, CSV, or fetched)
[ ] Phase 2 — Matched to Vibe Prospecting prospect IDs
[ ] Phase 3 — Profiles and contact info enriched
[ ] Phase 4 — Career signals fetched (job changes, promotions)
[ ] Phase 5 — Professional synopses written by Claude
[ ] Phase 6 — Delivered as in-chat cards and/or CSV export
Troubleshooting
| Problem | Solution |
|---|---|
| Vibe Prospecting tools missing | Connect from connector store; wait for mcp__*__fetch-entities to appear |
| Low match rate | Add LinkedIn URLs or emails to input — they're the strongest match signals. Names alone match poorly for common names |
| Profile data sparse | Not all profiles are equally populated. Flag thin records to the user and note what's missing |
| No contact info returned | Some people have limited public contact data. Note it in the synopsis card rather than leaving it blank |
| Career events empty | Person may not have changed jobs recently — note their tenure in current role instead |
| Synopsis feels generic | Claude needs data to work with — if enrichment returned little, flag the record rather than inventing details |
Decision-Makers Map
Map the buying committee at one target account: who matters, what role they play, and who to engage first.
Input
$ARGUMENTS is an account identifier plus optional context.
- Account identifier (required): a company domain (preferred) or a company name.
- Research context (strongly recommended): why this map is being pulled and what decision it supports. Capture as much as is true: deal stage and value, offering in play, recent activity or stalls, who is already engaged, who is missing, competitive pressure, persona priorities, timing, and any working hypothesis to test.
Example phrasings:
- "Map the buying committee at acme.com. Stage 3 deal, $400K ARR, security platform. We talked to the Director of SecOps but the CISO is quiet: find the economic buyer and any procurement blockers."
- "Decision-makers at Globex for a Data Platform pitch. Cold prospecting, likely Eng or Data leadership, flag CFO if cost story applies."
- "Renewal in 90 days at initech.com, champion left last quarter. Find the new owner and anyone who could block renewal."
If only a bare token is supplied with no context, ask once. If declined, default to general committee mapping for prospecting and state that assumption in the TL;DR.
Workflow
-
Anchor on purpose. Restate the research context in 1-2 sentences as the map purpose. Derive priority personas (3-6 titles or functions), priority seniority levels, priority departments, and any named hypotheses ("find the economic buyer").
-
Resolve the account: match a business from domain or name, then enrich a business with firmographics for company name, headcount, revenue range, industry, and HQ. Domain-variant sanity check: if a major-brand input resolves to a tiny headcount with a "Corporate Managing Offices" or "Hotels and motels" classification, the match likely routed to a registered-agent shell entity. Re-try with the alternate domain or company-name string. If no confident match, surface the ambiguity rather than guessing.
-
Discover canonical values for the committee search. For every priority title, discover canonical job-title strings the filter surface accepts. Title-only filters are NOT enforced as strict exact-match: combine title with a seniority filter to tighten.
-
Size the committee. Run a count (statistics, not retrieval) scoped to the resolved company plus the priority title and seniority filters. Country caveat: country scoping is approximate at the statistics layer; read the per-location category breakdown and sum the requested ISO-2 codes. If the total is very large (above ~500), tighten with department or higher seniority; if very small (under ~10), loosen by dropping seniority or adding adjacent titles.
-
Sample the committee broadly (retrieval, not filtering). Sample a small slice of prospects matching the resolved account plus the title and seniority filters, using presence-of-email as a contact-quality proxy. Treat the preview as a sample, not a ranked top-N. Run a second sample for adjacent functions named in the context (Procurement, Legal, Finance) so coverage gaps are visible.
-
Account-context signals. Fetch business events for the resolved account scoped to the last 90 days. There is no executive-move or departure enum: closest signals are an undifferentiated
employee_joined_companyand department-level hiring events. Flag this as a capability gap in the brief. Also triage funding and strategy signals that change the buying dynamic. Optionally enrich the account with strategic insights, challenges, and competitive landscape when a named hypothesis ties to a strategic theme. Event-attribution sanity check: confirm any event row actually names the target account before quoting it. -
Enrich and deep-research the top contacts. Merge prospects from step 5, dedupe, and rank by seniority, persona fit, hypothesis fit, and presence of email or LinkedIn URL. Enrich the top contacts with contacts and profiles, defaulting to email-only (cheaper; switch on phone only for SDR dialer flows). For the top 3-5 stakeholders, surface recent activity from the business-side LinkedIn-posts enrichment (per-prospect LinkedIn-posts is not exposed).
-
Synthesize. Each retrieval is raw context; decide what makes the map.
- Events triage: keep new-hire, executive-move, and promotion signals at director-level and above, especially in priority or adjacent functions. For each newly-named person, match a prospect if not already enriched and add to the committee with a RECENTLY APPOINTED flag and event date.
- Role classification (conservative): Champions require explicit engagement evidence (CRM activity, demo, prior emails); title alone is never sufficient, default to Potential Champions under Influencers. Technical Evaluators are director-and-above in Engineering, IT, or the function being sold to. Economic Buyers hold budget: C-Level Finance, the sponsoring function head, or CEO for strategic deals. Influencers use named sub-buckets (Procurement, Legal / Compliance, Operations, Adjacent Marketing, HR / Talent, Potential Champions).
- Hypothesis check: address each named hypothesis as confirmed, contradicted, or unresolved.
- Source tagging: tag every contact with where it came from (committee sample, event-derived, freshly matched).
-
Write the exec summary last. Re-read the body, then write the TL;DR at the top, framed by the map purpose.
Output Format
Decision-Makers Map: [Company Name]
Header line: industry | headcount / size bucket | revenue bucket | HQ.
TL;DR
Map purpose (restated in one line, or "general committee mapping for prospecting" if defaulted). One paragraph with: top 3 contacts to engage (named, one-line reasoning each), biggest coverage gap, single-thread risk, and a one-line answer to each named hypothesis. Sample preview phrasing for committee tables: "Sample preview (top 20 of matches)."
Company Snapshot
One paragraph: what they do, where they sit, key firmographic and strategic signals.
Account Context
Deal status, engaged stakeholders, key signals (leadership moves, funding, strategic shifts), open issues / blockers. Pull from user context where available.
Committee Map (tables)
Per category, a 5-column table with columns: Name, Title, Email, Status, Source. Skip empty categories.
- Economic Buyers
- Champions (only if explicit engagement evidence exists; otherwise "No Champions identified. See Potential Champions under Influencers.")
- Technical Evaluators
- Influencers (one table per sub-bucket that has contacts: Procurement, Legal / Compliance, Operations, Adjacent Marketing, HR / Talent, Potential Champions)
- Recently Appointed (last 90 days): same 5 columns plus Appointment Date; these also appear in their primary category with a RECENTLY APPOINTED flag.
Key Stakeholders (top 3-5)
Per stakeholder: Role classification, Background (career summary, time in role), Engagement history (or "No prior engagement recorded"), Why they matter, Flags (no email on file, RECENTLY APPOINTED, source disagreements), Recommended approach tied to the hypothesis or coverage need.
Engagement Strategy
Specific to this account, not a generic playbook. Anchor each step to a named person and a real signal.
- Immediate priorities (next 2 weeks): top 3 actions tied to specific people and signals.
- Coverage gaps: specific empty persona slots ("No Finance stakeholder below the CFO; director-level FP&A search recommended").
- Sequencing: ordered outreach with named people and reasons.
- Single-thread risk: current dependencies and the moves to fix them.
Excluded / Needs Verification
Table with Name, Reason, Recommended Action. Use for prospects with no email and no LinkedIn URL, ambiguous title matches, or names returned only by events that could not be resolved.
Next Steps
Concrete next actions, each referencing a specific person, persona gap, hypothesis, or signal, and tied to the map purpose.
Limitations
- Strategic-insights and challenges are sourced from SEC 10-K filings: all-null for private companies, and can be 12-18 months stale for public ones. Use events, funding, workforce trends, and LinkedIn posts for current-state signals.
- No native contact data-quality sort. Use presence-of-email as a proxy for reachable contacts.
- No executive-move or departure event enum. Closest signals are undifferentiated new-hire and department-level hiring; executive-level moves must be inferred from other sources and flagged as a capability gap.
- No sub-department job-function filter. Combine canonical title values with department to approximate functions like "FP&A" or "SecOps".
- No CRM-engagement signal in the data surface. Champion designation depends on engagement evidence supplied in the user context; without it, default to Potential Champions under Influencers.
- Bucket-only company size and revenue. Use bucket labels when describing the account snapshot.
- Department is null for many cross-functional senior roles (Chief X Officer, President, Founder). Group under "Unattributed" rather than dropping.
Enrich Company
Resolve a single company and return a complete profile across firmographics, tech, financials, funding, hiring, and contact coverage.
Input
The user will provide one of:
- A domain (e.g.
stripe.com) - A company name (e.g.
Stripe) - A known Explorium
business_id
Optional: a specific area of focus (e.g. "just funding", "tech stack only"). If omitted, run the full profile.
Workflow
-
Resolve the company. Match the business from the supplied domain, name, or id. If a name is ambiguous, re-match with user-supplied tiebreakers (country, HQ city, domain hint) and surface the top 3 candidates for a pick. If a
business_idis given, treat it as already resolved. If nothing resolves, stop and suggest re-trying with a domain. -
Domain-variant sanity check. After firmographics land, if a major-brand input resolves to a row with headcount 1-50 and NAICS
551114(Corporate Managing Offices) or SICHotels and motels, the match likely routed to a registered-agent shell. Re-try with the alternate domain or with the company name string before continuing. -
Enrich the core profile. Run firmographics, technographics, company hierarchies, funding and acquisitions, workforce trends, strategic insights, company ratings, and competitive landscape on the resolved company.
-
Add financial metrics. Financial metrics require a reporting date. Default to the first day of the current month, or use the most recent month the user names, and state the assumption.
-
Size the contact pool. Get a total prospect count scoped to the resolved company. Record it as "Contacts in Explorium" so the user can decide whether to chase decision-makers next.
-
Focused mode. If the user asked for one slice only (e.g. "just tech stack", "funding only"), run only the relevant enrichments in step 3 plus steps 1, 2, and 5.
-
Render the profile using the format below. Always surface
business_idandcompany_domainso the user can chain into follow-up work.
Output Format
[Company Name] : [one-line description from strategic insights or firmographics]
| Field | Value |
|---|---|
| Website | domain |
| Industry | LinkedIn or NAICS category |
| Headcount | bucket plus exact count when present |
| Revenue | bucket plus range when present |
| HQ Location | city, region, country |
| Company Type | public / private / subsidiary |
| Ticker | if public |
| Phone | |
| business_id |
Corporate Structure: ultimate parent, direct parent, subsidiary count and top names. Financials: reporting period plus key metrics (revenue, growth, margin where present). Funding & Acquisitions: total raised, last round (stage, amount, date, lead investor), recent acquisitions. Workforce Trends: headcount now vs 6 / 12 / 24 months ago, net hires last quarter, top hiring departments. Tech Stack: group by category (CRM, analytics, infra), cap at top 15 named tools. Competitive Landscape: top named competitors and positioning notes. Strategic Insights: 3-5 bullets on recent direction, priorities, or signals. Ratings: Glassdoor, G2, and other review signals when returned. Contact Coverage: total prospect count plus a suggested next step to pull decision-makers filtered by seniority and department.
Limitations
- Strategic insights and challenges are sourced from SEC 10-K filings: null for private companies, and 12-18 months stale for public ones. Use business events, funding, workforce trends, and LinkedIn posts for current-state signals.
- Exact headcount and exact revenue are not always returned: bucket values are the floor.
- No native "similar companies" tool. Approximate by reconstructing seed attributes and re-fetching with those filters (see the lookalike-accounts skill).
- Quarter-over-quarter and year-over-year headcount deltas may be partial for smaller or private companies.
- Financial metrics require a reporting date: default to current month and state the assumption.
- High-profile executives at the resolved company often have suppressed contact data. If the user pivots to "who runs it", warn that professional emails for top execs are unreliable and recommend LinkedIn outreach for that tier.
- Sub-industry granularity is limited to whichever taxonomy you filtered on (LinkedIn and NAICS categories are mutually exclusive as filters, though both can appear in firmographics output).
Enrich Contact
Resolve one person and return their full enriched profile in a single pass.
Input
The user will supply one of:
- An email address (e.g.
jane@acme.com) - A full name plus a company name or domain (e.g.
Jane Smith at Acme Corp) - A LinkedIn profile URL
- A known Explorium
prospect_id
Optional: a request for company context (firmographics on the matched employer).
Workflow
-
Classify the identifier. Pick exactly one resolution path: do not fan out match strategies in parallel. Use the strongest signal first and fall back only if it returns no match.
- Email present and well-formed: path A.
- LinkedIn URL: path B.
- Bare
prospect_id: path D, skip resolution. - Full name plus a company token: path C.
- Phone-only: stop and tell the user phone-only is not a supported match key.
-
Resolve the prospect.
- Path A: match the prospect by email.
- Path B: match the prospect by LinkedIn URL.
- Path C: if the user gave a company name, first resolve the business to get its canonical domain and
business_id, then match the prospect by full name plus that company domain or id. - Path D: use the supplied id directly.
-
Handle ambiguity. If matching returns zero rows:
- For path A, retry by splitting the email local-part into a name guess plus the company domain.
- For path C, retry with first/last name and the resolved
business_idfrom a company match. - If multiple plausible rows return, surface a candidates table and ask the user to pick. Never silently take the first row.
-
Enrich the prospect. Pull contacts and profile on the resolved person. Default to email-only contacts (cheaper); upgrade to email plus phone only when the user explicitly needs phone numbers (e.g. SDR dialer flows).
- Recent LinkedIn post content for an individual is not available. If the user asks for post content, surface this gap and offer the employer's LinkedIn posts via business enrichment instead.
-
Optional company context. If the user asked for company context (or path C resolved a
business_id), enrich firmographics on the employer and surface headcount, revenue range, country, and industry. -
Assemble the output. Render the card below. Omit empty fields. Always surface the
prospect_id.
Output Format
[Full Name] at [Company]
| Field | Value |
|---|---|
| Job Title | |
| Job Level | display canonical (e.g. c-suite, vice president) |
| Job Department | fallback "Unattributed" when null |
| Professional Email / Personal Email / Phone | |
| LinkedIn URL | |
| Company / Domain / Industry | |
| Company Size / Revenue / Country | buckets |
| prospect_id / business_id |
If multiple candidates surfaced during resolution and the user has not yet picked, render a ### Candidates table instead, with one row per candidate (name, title, company, domain, prospect_id) and ask which to enrich.
Limitations
- High-profile public execs (CEOs, founders, well-known executives) often have suppressed contact data. Professional email may be null or only a personal address. Recommend LinkedIn outreach instead of cold email for this tier.
- Phone-only lookup is not a supported match key.
- No per-prospect accuracy or confidence score. Treat the presence of a professional email plus phone as the practical quality signal.
- No
last_updatedtimestamp per contact field. Level and department are coarse buckets; department is null for many cross-functional senior roles (Chief X Officer, President, Founder), group under "Unattributed". - Company size and revenue are bucketed, not exact numbers.
HubSpot Enrichment & Scoring
Enrich your HubSpot CRM with Explorium data and write ICP fit scores directly back to your records. Claude runs the full pipeline: pull from HubSpot → match & enrich via Vibe Prospecting → score → push back.
What you'll end up with:
- Enriched company records: firmographics, tech stack, funding history, intent signals
- An ICP fit score (0–100) and tier (A/B/C) on every company
- All of it written back to HubSpot as custom properties, ready for segmentation and sequencing
Step 0 — Credential Check (Claude: always do this first)
Do not touch Phase 1 until both checks pass.
Vibe Prospecting
Cowork mode: look for a tool matching mcp__*__fetch-entities in your tool list.
- ✅ Found → proceed
- ❌ Missing → tell the user: "Please connect the Vibe Prospecting connector from the connector store, then let me know when it's done." Wait. Do not continue until the tool appears.
Claude Code / terminal:
npx @vibeprospecting/vpai@latest --help
- ✅ Lists tools → proceed
- ❌ Error → run:
npx @vibeprospecting/vpai@latest config --api-key "YOUR_VP_API_KEY"(get key from vibeprospecting.com → Settings → API Keys)
HubSpot Token
Ask the user: "Please paste your HubSpot Private App token (starts with pat-). I'll verify it and we'll get started."
Don't have one yet? Create it in HubSpot → Settings → Integrations → Private Apps → Create a private app. Enable scopes: crm.objects.companies.read, crm.objects.companies.write. Click Create and copy the token.
Once the user provides the token, verify it:
export HUBSPOT_TOKEN="<token-from-user>"
curl -s "https://api.hubapi.com/crm/v3/objects/companies?limit=1" \
-H "Authorization: Bearer $HUBSPOT_TOKEN" \
| python3 -c "
import json, sys
d = json.load(sys.stdin)
print('✅ Connected') if d.get('results') is not None else print('❌ Failed:', d.get('message','unknown error'))
"
- ✅ Connected → tell the user "Both credentials verified — let's go." Proceed to Phase 1.
- ❌ Failed → tell the user the token didn't work, ask them to check the scopes and try again. Do not proceed.
The token lives only in the session environment variable. It is never stored or logged.
Phase 1 — Pull Companies from HubSpot
Export your HubSpot company records. The match keys are name and domain — domain is the more reliable one.
For up to 100 companies:
curl -s "https://api.hubapi.com/crm/v3/objects/companies?limit=100&properties=name,domain,hs_object_id,lifecyclestage,numberofemployees,annualrevenue,industry" \
-H "Authorization: Bearer $HUBSPOT_TOKEN" \
| python3 -c "
import json, sys, csv
data = json.load(sys.stdin)
fields = ['hs_object_id','name','domain','lifecyclestage','numberofemployees','annualrevenue','industry']
w = csv.DictWriter(sys.stdout, fieldnames=fields, extrasaction='ignore')
w.writeheader()
for r in data['results']:
row = {'hs_object_id': r['id']}
row.update(r['properties'])
w.writerow(row)
" > hs-companies-raw.csv
echo "Exported $(wc -l < hs-companies-raw.csv) rows"
For larger exports (paginated):
import csv, os, requests
TOKEN = os.environ["HUBSPOT_TOKEN"]
HEADERS = {"Authorization": f"Bearer {TOKEN}"}
PROPS = "name,domain,hs_object_id,lifecyclestage,numberofemployees,annualrevenue,industry"
FIELDS = ['hs_object_id','name','domain','lifecyclestage','numberofemployees','annualrevenue','industry']
rows, params = [], {"limit": 100, "properties": PROPS}
while True:
resp = requests.get("https://api.hubapi.com/crm/v3/objects/companies", headers=HEADERS, params=params)
resp.raise_for_status()
data = resp.json()
for r in data["results"]:
row = {"hs_object_id": r["id"]}
row.update(r["properties"])
rows.append(row)
after = data.get("paging", {}).get("next", {}).get("after")
if not after:
break
params["after"] = after
with open("hs-companies-raw.csv", "w", newline="") as f:
w = csv.DictWriter(f, fieldnames=FIELDS, extrasaction="ignore")
w.writeheader()
w.writerows(rows)
print(f"Exported {len(rows)} companies")
Tips:
- If many records are missing
domain, clean those in HubSpot before running this skill — domain is the primary match key and missing domains won't match. - To enrich only a subset (e.g. leads and MQLs), filter
lifecyclestageafter export before passing to Phase 2.
Output: hs-companies-raw.csv
Starting from scratch with no existing HubSpot records? Skip to Phase 2 and use
fetch-entitiesto build a net-new account list from your ICP, then push those as new HubSpot companies in Phase 5.
Phase 2 — Match to Vibe Prospecting IDs
Resolve company names and domains to Explorium business IDs. These IDs are required for all enrichment steps.
# Always check schema before first use
npx @vibeprospecting/vpai@latest match-business --all-parameters
# Match from the exported CSV
npx @vibeprospecting/vpai@latest match-business \
--file-path hs-companies-raw.csv \
--schema '{"name":"name","domain":"domain"}' \
--tool-reasoning 'Match HubSpot companies to Vibe Prospecting IDs for enrichment'
Note the session_id and table_name from the JSON output — you'll pass these to every subsequent step.
Drop any matches with confidence < 0.7 before proceeding.
Output: matched companies in session DB (vp-matched table)
Phase 3 — Enrich
Pull firmographic, technographic, funding, and intent data for every matched company.
npx @vibeprospecting/vpai@latest enrich-business --all-parameters
npx @vibeprospecting/vpai@latest enrich-business \
--args '{
"enrichments": ["firmographics", "technographics", "funding-and-acquisitions"]
}' \
--session-id <SESSION_ID> \
--table-name <TABLE_NAME_FROM_MATCH_STEP> \
--tool-reasoning 'Enrich HubSpot companies with Vibe Prospecting data' \
--csv
Available enrichment categories:
| Category | What you get |
|---|---|
firmographics | Revenue, headcount, industry, HQ location, founding year |
technographics | Full tech stack — CRM, marketing automation, data tools, infra |
funding-and-acquisitions | Total raised, last round type/date/amount, investors |
intent | Topics the company is actively researching (requires intent add-on) |
Output: vp-enriched.csv
Phase 4 — Score on ICP Fit
Ask the user for their ICP criteria if not already provided:
"To score these companies, I need to know your ideal customer profile. What industry, company size, revenue range, and tech stack signals matter most? And how would you weight them?"
Then read vp-enriched.csv and score each row. Add three columns:
| Column | Description |
|---|---|
icp_score | 0–100 fit score |
icp_tier | A (80–100), B (60–79), C (40–59), Disqualified (<40) |
icp_score_reason | One-line explanation |
Default weights (adjust to the user's ICP):
- Industry match: 25%
- Headcount match: 25%
- Tech stack match: 30%
- Revenue/funding match: 20%
Save output to vp-scored.csv.
Phase 5 — Push Back to HubSpot
Step 1 — Create custom properties (one-time)
Run this once to create the Vibe Prospecting properties in HubSpot. Skip any that already exist.
for PROP_JSON in \
'{"name":"vp_icp_score","label":"ICP Score (Vibe)","type":"number","fieldType":"number"}' \
'{"name":"vp_icp_tier","label":"ICP Tier (Vibe)","type":"string","fieldType":"text"}' \
'{"name":"vp_icp_score_reason","label":"ICP Score Reason (Vibe)","type":"string","fieldType":"text"}' \
'{"name":"vp_headcount","label":"Headcount (Vibe)","type":"number","fieldType":"number"}' \
'{"name":"vp_annual_revenue","label":"Annual Revenue (Vibe)","type":"number","fieldType":"number"}' \
'{"name":"vp_tech_stack","label":"Tech Stack (Vibe)","type":"string","fieldType":"textarea"}' \
'{"name":"vp_total_funding","label":"Total Funding (Vibe)","type":"number","fieldType":"number"}' \
'{"name":"vp_last_funding_type","label":"Last Funding Type (Vibe)","type":"string","fieldType":"text"}' \
'{"name":"vp_last_funding_date","label":"Last Funding Date (Vibe)","type":"string","fieldType":"text"}'; do
curl -s -X POST "https://api.hubapi.com/crm/v3/properties/companies" \
-H "Authorization: Bearer $HUBSPOT_TOKEN" \
-H "Content-Type: application/json" \
-d "$PROP_JSON" | python3 -c "import json,sys; d=json.load(sys.stdin); print(d.get('name','?'), '—', 'created' if 'name' in d else d.get('message','error'))"
done
Step 2 — Batch update company records
import csv, json, os, requests, time
TOKEN = os.environ["HUBSPOT_TOKEN"]
HEADERS = {"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"}
with open("vp-scored.csv") as f:
rows = list(csv.DictReader(f))
def build_batch(chunk):
return [
{
"id": row["hs_object_id"],
"properties": {
"vp_icp_score": row.get("icp_score", ""),
"vp_icp_tier": row.get("icp_tier", ""),
"vp_icp_score_reason": row.get("icp_score_reason", ""),
"vp_headcount": row.get("employee_count", ""),
"vp_annual_revenue": row.get("annual_revenue", ""),
"vp_tech_stack": row.get("tech_stack", ""),
"vp_total_funding": row.get("total_funding", ""),
"vp_last_funding_type":row.get("last_funding_type", ""),
"vp_last_funding_date":row.get("last_funding_date", ""),
}
}
for row in chunk
]
# Batch in groups of 100
for i in range(0, len(rows), 100):
chunk = rows[i:i+100]
resp = requests.post(
"https://api.hubapi.com/crm/v3/objects/companies/batch/update",
headers=HEADERS,
json={"inputs": build_batch(chunk)}
)
print(f"Batch {i//100 + 1}: {resp.status_code}")
if resp.status_code == 429:
print("Rate limited — waiting 10s")
time.sleep(10)
Output: HubSpot company records updated with enriched fields + ICP scores
Phase 6 (Optional) — Enrich Contacts at Top Accounts
Scope to A-tier accounts only (ICP score ≥ 80) before fetching contacts — keeps the batch focused and cost-efficient.
# Fetch key contacts at top-scored companies
npx @vibeprospecting/vpai@latest fetch-entities \
--args '{
"entity_type": "prospects",
"filters": {
"job_level": {"values": ["vice president", "director", "c_suite"]},
"job_department": {"values": ["sales", "revenue_operations", "marketing"]},
"has_email": true
}
}' \
--businesses-table-name <TABLE_NAME_FROM_ENRICH_STEP> \
--session-id <SESSION_ID> \
--number-of-results 200 \
--tool-reasoning 'Fetch key contacts at top ICP accounts for HubSpot'
# Enrich with verified contact info
npx @vibeprospecting/vpai@latest enrich-prospects \
--args '{"enrichments": ["contacts", "profiles"]}' \
--session-id <SESSION_ID> \
--table-name <FETCH_PROSPECTS_TABLE> \
--csv \
--tool-reasoning 'Enrich contact info for HubSpot push'
Then upsert contacts into HubSpot using /crm/v3/objects/contacts/batch/upsert, matching on email. Set hs_additional_domains or associate to the parent company using the associations API.
Full Checklist
[ ] Step 0 — Vibe Prospecting connected, HubSpot token verified
[ ] Phase 1 — Companies exported to hs-companies-raw.csv
[ ] Phase 2 — Matched to Vibe Prospecting IDs
[ ] Phase 3 — Enriched (firmographics, tech stack, funding)
[ ] Phase 4 — ICP scores computed and tiered (A/B/C)
[ ] Phase 5 — HubSpot properties created; company records updated
[ ] Phase 6 — (optional) Contacts enriched and pushed to HubSpot
HubSpot Custom Properties Written
| Property | Type | Description |
|---|---|---|
vp_icp_score | Number | ICP fit score 0–100 |
vp_icp_tier | Text | A / B / C / Disqualified |
vp_icp_score_reason | Text | One-line score rationale |
vp_headcount | Number | Employee count from Explorium |
vp_annual_revenue | Number | Estimated annual revenue |
vp_tech_stack | Text | Comma-separated tech stack |
vp_total_funding | Number | Total funding raised (USD) |
vp_last_funding_type | Text | Series A / Seed / PE / etc. |
vp_last_funding_date | Text | Date of most recent round |
Troubleshooting
| Problem | Solution |
|---|---|
| Vibe Prospecting tools missing in Cowork | Open connector store → connect Vibe Prospecting → wait for tools to appear |
| HubSpot 401 Unauthorized | Token is wrong or scopes missing — recreate the Private App with correct scopes |
| Low match rate | Ensure domain is populated on HubSpot records — it's the primary match key |
| HubSpot 429 Rate Limit | Batch update allows 100 records/call; script already handles this with time.sleep |
| Property already exists error on Step 1 | Safe to ignore — the property is already there |
| Contacts not linking to companies | Use the HubSpot associations API after upsert to link contacts to their parent company |
Lead Gen Tool Builder
Scaffolds a working, self-hostable lead generation tool: a ZoomInfo-style web app with a left filter rail, a sortable company/contact results table, and a CRM push bar — backed by the Explorium data API, with CSV import/export and field-mapped push to HubSpot and Salesforce.
Unlike the other skills in this repo, which run a prospecting or enrichment
workflow inside your current Claude Code session via the Vibe Prospecting
MCP server, this skill produces a standalone app the user can run, deploy,
and hand to their team — a real lead-gen tool, not a one-off list. Reach for
list-builder or enrich-company when the user wants a prospect list right
now; reach for this skill when they want a tool they can keep using, host,
demo, or white-label.
No personal keys are stored in this skill. The bundled backend reads every
credential from a local .env file at runtime — nothing is hardcoded, so the
generated app is safe to fork, self-host, and share outside your org.
When to use
Trigger this for any request to build a lead-gen / prospecting / sales- intelligence app, a company-or-contact search interface, an Explorium-powered app, a self-hosted ZoomInfo/Apollo.io/Clearbit alternative, or a "find leads → enrich → push to CRM" tool that should exist as its own app rather than a single list. Example phrasings: "build me a lead gen tool", "I want something like ZoomInfo but self-hosted", "scaffold a prospecting app with HubSpot push", "give my team a company search tool backed by Explorium".
What you get
The bundled template (assets/leadgen-starter/) is a ready-to-run app:
- Company generator and Contact generator — two search modes over
Explorium's
/businessesand/prospectsendpoints. - Filter rail mapped 1:1 to Explorium fields: industry, employee count, revenue, company age, HQ country/region/city, tech stack, keywords, business events (funding, hiring, M&A…); for people — job title, seniority, department, has-email / has-phone availability.
- Sample-aware results table — sortable columns, bulk select, detail panel; the UI is explicit when Explorium returns a capped sample vs. every match.
- Import a list — upload a CSV of companies or contacts, match it against Explorium, and enrich it.
- CSV export of any result set or selection.
- Push to CRM with a reviewable, editable field-mapping modal — Contacts → Salesforce Leads / HubSpot Contacts; Companies → Salesforce Accounts / HubSpot Companies.
Workflow
1. Copy the template into the user's workspace
cp -R "<this-skill-dir>/assets/leadgen-starter" ./leadgen-app
cd leadgen-app
Don't copy node_modules, dist, or .env — the template ships without them.
2. Get API keys
Only Explorium is required to search; HubSpot/Salesforce are optional and only
needed for CRM push. Summarize from assets/leadgen-starter/README.md:
- Explorium (required): sign up at developers.explorium.ai → API Keys.
- HubSpot (optional): Settings → Integrations → Private Apps → create app
with
crm.objects.contacts.write+crm.objects.companies.writescopes. - Salesforce (optional): a Connected App using the OAuth 2.0 JWT Bearer
flow — the bundled README has the exact
openssl+ Connected App steps.
3. Configure and run
cp .env.example .env # paste in the keys from step 2
npm install
npm run dev # API on :4000, web app on :5173
Open http://localhost:5173. Search works with just the Explorium key; the
HubSpot/Salesforce push buttons activate once those keys are present.
4. Verify
Run a small company search (e.g. Country = US, Employees = 51-200) and confirm real results load. If CRM keys were provided, select a couple of rows and push to confirm the success modal returns real created-record IDs.
Architecture
server/— Node/Express backend; the only place API keys ever live.explorium.jsis the REST client (search, match, bulk-enrich, autocomplete — note several filter fields have distinct Explorium filter types, e.g.job_titleisany_match_phraseandhas_emailisexists, handled inbuildFilters).salesforce.js/hubspot.jsdo CRM auth plus mapping-driven record creation.src/— React + Vite + Tailwind frontend that only calls/api/*— it never sees a credential.config/filters.tsdefines every filter;components/holds the filter rail, results table, and CRM modals.
Customizing
- Filters: edit
src/config/filters.ts. Field names and value enums must match Explorium's API — the client surfaces the API's own validation errors (which list permitted values) if a field or value is wrong. - Branding: product name in
src/components/TopBar.tsx, logo mark insrc/components/icons.tsx, palette intailwind.config.js, tab title/ favicon inindex.html. - CRM field maps: defaults live in
SF_DEFAULT_MAPPING(server/ salesforce.js) andHS_DEFAULT_MAPPING(server/hubspot.js). Note SalesforceIndustryand HubSpotindustryare restricted picklists, so free-text industry is mapped to a description field by default — adjust if your org has custom picklist values. - Swap the data layer: the template calls Explorium's REST API directly.
To reuse the same MCP-native data layer as the rest of this repo, point the
backend at the Vibe Prospecting MCP server (
https://vibeprospecting. explorium.ai/mcp) instead of raw REST calls.
Limitations
- Explorium's fetch endpoints return a capped sample for broad queries (not the true match count) — the UI flags this; narrow filters to see the full set.
- Enrichment (contact reveals, list-import match/enrich) consumes Explorium credits — the app only enriches selected rows or rows being pushed, never whole result pages.
- This is a starter, not a production deployment: for real usage, move secrets to a managed vault and add auth, rate-limiting, and logging.
List Builder
Turn a natural-language audience brief into a clean, exportable prospect or business list.
Input
$ARGUMENTS is a free-text description of the audience. Parse it for:
- Entity type (prospects vs businesses; default prospects if ambiguous).
- Role signals: job titles, seniority, department.
- Firmographics: industry, size bucket, revenue bucket, company age, public vs private.
- Geography: country, US/Canadian state, or city region.
- Technographics, intent topics, growth events with a recency window in days.
- Contactability: reachable / emailable.
- Count (default 25), fields requested (e.g. "include phone") that drive which enrichments layer on top.
Example phrasings: "100 VP Engineering at Series B SaaS in the US that use Snowflake", "heads of demand gen at 200-1000 fintech in NYC", "50 CFOs at public manufacturing that raised funding in the last 90 days", "cybersecurity under 500 employees in the UK with intent on zero trust".
Workflow
-
Decide list type. Prospects if the brief names person attributes (title, seniority, department). Businesses if only company attributes are named. If prospects are scoped by a prior company set, plan to thread that businesses table into the prospect fetch.
-
Discover canonical values. For every free-text field (industry, technology, job title, intent topic, city region), resolve the user's phrase to the standardized value the API expects. Skip discovery for ISO country codes, region codes, bucket enums (size, revenue, age), seniority and department enums, and boolean flags.
-
Tighten loose title filters. Title filters are not enforced as exact-match: a job-title-only filter for "Vice President of Engineering" can return non-VP rows. Always combine a title with a seniority value (e.g. "vice president") to keep the slice tight.
-
Size the audience. Get a total match count for the assembled filters before pulling rows. Use this number to frame the preview honestly and to warn the user early if the audience is unexpectedly small or massive.
-
Sample-first preview. Pull a small slice (5 rows) and render it for the user to sanity-check the filter translation before materializing the full list. The interactive preview is hard-capped at 5 rows: treat it as a sanity sample, not as the ranked top-N.
-
Pull the full list. Once the preview is approved, materialize the requested count via the paid export path. Restate the audience definition so the user can see what locked in.
-
Enrich the rows. For prospects, default to email-only contact enrichment (cheaper); add phone only when the user explicitly asks for it (e.g. dialer flows). Add profile data for LinkedIn URL and bio when requested. Prospect-side LinkedIn post content is NOT available: for recent activity, enrich LinkedIn posts on the employer instead. For businesses, layer in firmographics, technographics, funding, workforce trends, competitive landscape, ratings, or strategic insights based on the fields the user asked for.
-
Output as a table artifact with the CSV path called out so the user can download or pipe it onward.
Output Format
Search Criteria Applied
Bulleted readout of every filter that landed: entity type, title and seniority, department, industry, size and revenue buckets, geography, tech stack, intent topics, growth events with their recency window, and any boolean flags. Call out any requested filter that had no direct equivalent and how it was approximated.
Prospect List
Show when entity type is prospects. Columns: name, job title, company, company domain, industry, company size, email (professional preferred), phone if pulled, LinkedIn URL, prospect_id. Drop columns the user did not ask for. Caveat: email and phone only populate after contact enrichment; the discovery preview returns identifiers only.
Business List
Show when entity type is businesses. Columns: company name, domain, industry, headcount, revenue bucket, country/region, plus any enrichment columns requested (tech stack, recent funding, hiring trend), business_id.
List Summary
Total matching audience from step 4, rows returned in this pull, path to the CSV artifact, enrichment coverage (e.g. "92 of 100 rows have a verified email"). Frame as "Sample preview (5 of matches)" when a total is available; never invent a total.
Refinement Options
Concrete next moves: tighten or broaden a bucket, add a reachability filter, swap geography granularity, layer a recent-event filter, pivot from businesses to prospects by reusing the current business table, add or remove an enrichment.
Limitations
- No native sort by contact data-quality, exact employee count, or revenue. Use the reachability flag, or tighten buckets.
- No metropolitan-area taxonomy: use city region discovery or state-level region codes.
- No native similar-companies tool: see the lookalike-accounts skill.
- No sub-department job-function filter. Combine a title (after discovery) with a department.
- No business-list ranking filter (Inc 5000, Fortune 500). Approximate with size, revenue, and public-company flag.
- Headcount and revenue are bucket enums, not exact numeric ranges.
- Title filters are loose: always pair with a seniority value to avoid false positives.
- The interactive preview is hard-capped at 5 rows: the full slice only materializes via the paid export path.
- Department is null for many cross-functional senior roles (Chief X Officer, President, Founder): group under "Unattributed".
Lookalike Accounts
Reconstruct the profile of one seed company, then surface other companies that share its industry, size, region, and tech stack.
Input
The user supplies via $ARGUMENTS:
- A seed company name or domain (required).
- Optional: how many lookalikes to return (default 25, ceiling 100).
- Optional overrides: country focus (country codes or grouped regions, pick one), size or revenue bucket, public-only flag, additional named tech stack components.
If the user gives only a person or asks for similar contacts, redirect them to a prospecting flow. This skill returns accounts.
Workflow
-
Resolve the seed. Match the supplied name or domain. If multiple candidates return, pick the highest-confidence match whose domain aligns with the user input and confirm the chosen company back in the final output. If nothing resolves, stop and ask for a clearer identifier (domain preferred).
-
Domain-variant sanity check. After firmographics land, if a major-brand input resolves to a row with headcount 1-50 and NAICS
551114(Corporate Managing Offices) or SICHotels and motels, the match likely routed to a registered-agent shell. Re-try with the alternate domain or with the company name string. A broken seed produces garbage lookalikes. -
Reconstruct the seed profile. Enrich firmographics and technographics on the seed. Extract:
- Industry category (LinkedIn or NAICS, whichever is populated; the two are mutually exclusive as filters).
- Headcount bucket and revenue bucket.
- Country code (or regional grouping if the seed is multinational and the user asked for regional scope).
- Top 3-5 tech stack values, biased toward category-defining tools (CRM, MAP, data warehouse, primary cloud) over ubiquitous infrastructure (Analytics, jQuery). Skip any field that comes back empty: never fabricate a value.
-
Discover canonical values for the reconstructed industry and each tech token. Drop any value that does not resolve cleanly. Bucket enums and country codes do not need discovery.
-
Apply user overrides. If the user specified country, size, revenue, public-only, or extra tech filters, replace or extend the reconstructed values with the overrides. Honor the mutual exclusivity rule between LinkedIn and NAICS industry, and between country code and grouped region.
-
Size the candidate pool. Get a total count for the assembled filters. If below the requested return size, relax the most restrictive filter first: drop the 5th tech, then 4th, then 3rd, then collapse the headcount bucket to an adjacent one. Re-size after each step. If the count exceeds 5,000, tighten by adding back a tech filter or narrowing region. Report the final candidate count in the output.
-
Fetch lookalikes. Sample the validated filter set to surface candidates, then export the user-requested count via the paid export path for the full materialized list. Exclude the seed before display.
Output Format
Header
Lookalikes for [Seed Company Name] ([seed domain]) Reconstructed profile: [industry] | [headcount bucket] | [revenue bucket] | [country or region] | Tech: [comma-separated tech list]. Candidate pool: [N] companies matching this profile. Returning top [requested count].
Results Table
| Rank | Company | Domain | Industry | Employees | Revenue | Country |
|---|
Show the user-requested count (default 25, cap 100). Always exclude the seed.
Pattern Notes
2-4 bullets covering dominant geography, size concentration, tech-overlap density (tech filters are not fully populated on every row), and any adjacency the filter set introduced (e.g. "industry widened because LinkedIn category was empty on seed").
Suggested Next Steps
Pull contacts at any of these accounts via the list-builder flow scoped by the businesses table; deepen one row with the enrich-company flow; watch the list for growth events on the reconstructed cohort.
Limitations
- No native similarity model. There is no lookalike API or ML similarity score. This skill approximates similarity by reconstructing the seed's firmographics, technographics, and industry, then doing a filtered company fetch on those reconstructed attributes. The native flow is match-seed, enrich attributes, then re-fetch with attributes. Results are ranked by default fetch order, NOT by a true similarity score.
- No similarity ranking column. No per-row similarity score is computed: rank reflects fetch order.
- Industry classification gaps. If neither LinkedIn nor NAICS category is populated, the skill falls back to size + region + tech, producing a looser approximation. Flag this in the output.
- Tech stack coverage is partial. Tech tokens are not exhaustively populated, so filtering on multiple values can collapse the candidate pool faster than expected. The relaxation logic in step 6 handles this.
- Bucketed size and revenue. A seed at the high edge of one bucket and a candidate at the low edge of the next can look further apart than they are.
- Region taxonomy is country-level. No metro or sub-country scope.
- High-profile execs at these accounts often have suppressed contact data: if the user pivots to "who runs these", recommend LinkedIn outreach for top execs.
- No contact-level lookalikes. This skill returns accounts only.
Market Sizing
Iteratively refine a company-level ICP filter set and return a count plus a structured filter artifact ready for downstream prospecting work.
Input
- ICP description (recommended): natural language, or "my ICP" / "our ICP" / nothing (ask).
- Use case (optional): territory design, investor sizing, ICP sharpening (default).
- SAM hypothesis inputs (optional): addressable fraction (0 to 1) and ARPA in USD.
Workflow
-
Parse the ICP into filter dimensions. Tag each user-specified or unspecified. Persona criteria ("CTOs", "VP Sales") are recorded but NOT applied to the company count.
-
Disambiguate ambiguous regions BEFORE counting. "EU" can mean European Union members or the broader European region: ask one clarifying question. Same for "Americas" vs "North America" vs "US and Canada".
-
Resolve every free-text field via autocomplete, then classify the result into ONE of three branches before sizing.
(a) Clean canonical match. An unambiguous value is returned for the user's phrasing (e.g. "Software Development" for SaaS; "Salesforce CRM" for a Salesforce filter). Commit and proceed.
(b) Brittle or parent-only match. The exact term does not exist in the taxonomy but a parent or sibling does (e.g. "fintech" maps only to a "Financial Services" parent; "Snowflake" only cleans up as "Snowflake Data Cloud" on a variant phrasing). STOP before sizing and surface the candidates to the user with a one-line disambiguation: "No exact match for
<term>; nearest entries are<list>. Approximate with<parent>, seed a known company for a lookalike follow-up, or proceed with a tech-stack or intent proxy?" Do NOT silently substitute the parent.(c) No match after 2-3 variant phrasings (bare term, full product name, vendor-plus-suffix like "Stripe Payments"). Surface "no matching value" and offer the same three options as (b).
For flagship vendors (Snowflake, Databricks, Stripe): try the suffix-qualified variant FIRST ("Snowflake Data Cloud", "Stripe Payments") because the bare token often returns a noise hit.
Taxonomy mutex. LinkedIn industry and NAICS are mutually exclusive on a single query. Query LinkedIn FIRST; commit on a clean (branch a) match; fall through to NAICS only on no-match. Dual-querying both taxonomies in the same pass is acceptable ONLY when LinkedIn lands in the brittle branch (b) AND the user has approved looking at both candidates.
-
Tech-stack taxonomy-gap framing. When step 3 lands in branch (c) for a flagship vendor, document this as a coverage gap, NOT a sparsity-narrow result. The skill cannot size around a tech filter with no taxonomy entry; the sparsity probe in step 6 measures something different and should not be conflated.
-
Size the audience. Get the total count for the resolved filter set. Country-scoped TAM caveat: the sizing endpoint does NOT strictly enforce country filters at the headline-count level. For any country-scoped TAM, sum the per-location breakdown across requested ISO-2 codes. Never use the global headline count when the user asked for a specific geography.
-
Data-sparsity probe (mandatory when tech-stack or intent filters are applied). Size twice: with the filter (count_filtered) and without it (count_unfiltered). If count_filtered / count_unfiltered is below 0.1, treat as coverage-sparse and use count_unfiltered as the operative TAM. Surface "Explorium coverage of [field] is sparse for this segment." Show both numbers.
-
Classify the sizing band against the operative TAM.
| Operative TAM | Band | Read |
|---|---|---|
| > 50,000 | Too broad | Probably not operational. |
| 5,000 to 50,000 | Healthy enterprise/mid-market | Suggest tier segmentation. |
| 1,000 to 5,000 | Sweet spot | Focused primary-tier list. |
| 250 to 1,000 | Tight/niche | Flag capacity feasibility. |
| < 250 | Too narrow | Coverage risk; suggest widening. |
-
Decide on sample accounts. Default: skip. Pull is paid; stats are free.
Pull a ~25-row sample ONLY when ONE of these triggers fires:
(a) User asked for account names, a quality sanity check, or a downstream list.
(b) Sparsity probe needs noise validation. Ratio in step 6 sits near the 0.10 threshold and you cannot tell from the counts alone whether the filter is sparse-but-real or sparse-and-noisy.
(c) Brittle match accepted in step 3. A parent-approximation or variant-qualified match was committed; entity-quality confirmation would tell you whether the substitution captured what the user meant.
If none of the triggers fire, return stats-only and note "stats-only" in the self-check. Skip the pull even when TAM <= 50,000. The 50,000 ceiling is a maximum, not a trigger.
When pulling: ~25 unsorted rows for ICP sanity (do top names look right, or include conglomerate / BPO / staffing noise?), directional geography and sub-industry shape, noise-rate estimation. The sample is unsorted: directional, not ranked. Do not compute employee or revenue percentages from it.
-
Noise-adjusted TAM (mandatory when sample noise is at least 20 percent). Compute
adjusted = round(operative_TAM x (1 - noise_rate), 2 sig figs). Re-classify the band against the adjusted number. Cite specific noisy rows. 20-60 percent noise signals revisiting the filter set, not shipping the count. -
SAM hypothesis (only if both inputs supplied). SAM count = operative TAM x addressable fraction. SAM revenue = SAM count x ARPA. Label clearly: hypothesis, not forecast.
-
Self-check: headline rounded to at most 2 sig figs; step 3 branch dispositions (clean / brittle-surfaced / no-match) recorded for every free-text field; taxonomy mutex respected (only one of {LinkedIn, NAICS} queried unless user approved dual after a brittle hit); sparsity probe and noise adjustment run when applicable; sample pull triggered for a documented reason from step 8 OR correctly skipped as "stats-only"; unspecified dimensions flagged; persona criteria marked "not applied to company TAM"; region disambiguation resolved; refinement options name a specific dimension and an estimated post-refinement count.
-
Present refinement options and loop. Too broad: 2-3 narrowing options with estimated impact. Too narrow: 2-3 widening options. Healthy band: tier segmentation or finalize. Always offer a "save filters" exit so downstream skills can consume the artifact. Re-run from step 3 when filters change and surface the diff. Terminate on finalize.
Output Format
- TL;DR: use case restated; headline
~[count] companies; band label. If the sparsity probe fired, show raw filtered, unfiltered, and operative TAM. If noise-adjusted, show raw, noise rate, adjusted, and the band classified against the adjusted number. 1-2 sentences on operational viability, dominant skew, most consequential refinement. If step 3 surfaced a brittle match, restate the chosen disposition (e.g. "fintech approximated by Financial Services parent, user-confirmed"). - Filters Applied: dimension, value, source (user-specified, unspecified, approximation), and step-3 branch tag for any free-text field (clean / brittle-approximated / proxy). Persona criteria flagged "NOT applied to company TAM."
- Sample Accounts (only when one of the step-8 triggers fired): up to 25 unsorted rows, with a one-line note citing WHICH trigger justified the pull. Sanity check; name the narrowing filter that removes any noise.
- Sizing Band & Refinement: band label, 1-2 sentences on operational implication, 2-3 refinement options each naming a dimension change and an estimated post-refinement count. Or finalize.
- SAM Hypothesis (only if both inputs supplied): TAM count, addressable fraction, SAM count, ARPA, SAM revenue. Hypothesis, not forecast.
- Final Filter Set (on finalize): structured artifact with resolved values for every applied dimension plus operative TAM, band, pass count, and use case.
Limitations
- Size and revenue are bucket filters; exact cutoffs cannot be expressed. Revenue buckets appear to be a deterministic employee-to-revenue heuristic, not real revenue data. 90%+ concentration in one bucket is expected; do not slice revenue after locking size.
- No native sort on entity fetch; samples are directional, not ranked.
- No metro taxonomy; geography resolves to country, region, or city autocomplete.
- No similar-companies tool inside this skill; seed-account workflows belong elsewhere.
- No sub-department job-function filter; persona is recorded only, never applied to the company count.
- No Inc / Fortune ranking filters; public-vs-private is the only company-type boolean.
- Industry taxonomy (LinkedIn vs NAICS) and country code vs region-country code are each mutually exclusive on a single query. Dual-querying is allowed under the brittle-branch exception in step 3, but the FINAL filter set must commit to one taxonomy per dimension.
- Flagship vendor names (Snowflake, Databricks, Stripe) sometimes require a suffix-qualified phrasing to autocomplete cleanly; bare-token queries can return noise. Step 3's branch (b) handling exists specifically to surface this brittleness rather than silently substitute.
Meeting Prep
Pull the company, signal, and attendee evidence the calling agent needs to write a tight, decision-ready brief for a ~30-minute meeting.
Input
- Account identifier (required): an Explorium business_id (preferred), or a company name or domain.
- Attendees (recommended): names and/or emails. Without attendees the brief is necessarily generic.
- Meeting context (strongly recommended): free-form description of purpose, stakes, prior discussions, deal stage, walk-out goals, known tensions, competitive context, the offering in play, hypotheses to test, and pitfalls. Flat enums produce flat briefs.
If the identifier is ambiguous: a string with a dot or known TLD is a domain; otherwise treat it as a name.
Workflow
Parallelize aggressively. Company enrichment fans out from the resolved account; per attendee, resolve and enrich profile evidence in parallel.
- Anchor on purpose. Restate the meeting context in 1-2 sentences. If missing, ask once; if the user declines, default to general prep and state that assumption. Derive purpose (1 line), desired outcome, 3-5 priority topics, named risks or hypotheses. These drive insight focus, attendee framing, talking-point ranking, and the suggested agenda.
- Match the business. If a business_id was supplied, use it directly. Otherwise resolve by name or domain. If no confident match, surface the ambiguity rather than guessing. Domain-variant sanity check: if firmographics show a major brand but headcount is 1-50 and the entity looks like a registered-agent shell, retry with the alternate domain (.so vs .com) or the company-name string.
- Enrich the business broadly: firmographics and technographics, funding and acquisitions, strategic insights and stated challenges, hiring direction and workforce trends, competitive landscape and company hierarchies, recent LinkedIn posts, website changes. Gather broadly now; decide relevance during synthesis.
- Fetch business events on a 30-90 day window. Treat events as raw signal to triage in step 6. Event-attribution sanity check: tie every event to the matched business; do not blend across the parent / subsidiary tree silently.
- Match and enrich attendees in parallel. Resolve each by email when available, otherwise by full name plus the resolved company. If an attendee cannot be resolved, note it; do not fabricate. Enrich each resolved person for profile (seniority, department, tenure, prior roles). Pull contacts only when the user intends to send outreach: default email-only (cheaper), switch to email + phone only when phone is required (SDR dialer flows). Per-prospect post history is a current gap; pull the employer's recent posts for voice instead.
- Hand back raw evidence for synthesis. The calling agent writes the narrative brief. Organize so the calling agent can: triage events and posts (keep items tied to purpose, deal stage, attendees, priority topics; drop generic press); classify per-attendee posture from employment history and recent voice (Cold, Warm-but-dormant with significant past tenure at a relevant prior employer, Active, Hostile); rank 3-5 talking points by relevance to the desired outcome, each tied to a specific surfaced fact and ideally a named attendee; mark each named hypothesis confirmed, contradicted, or unresolved; tag claims by source category; flag any past-dated milestone for verification rather than dropping silently.
- Write the TL;DR last, framed by the meeting purpose and desired outcome.
Output Format
- TL;DR: meeting purpose / desired outcome in one line (or "general meeting prep (no context supplied)" if defaulted); top 3 to know walking in, each tied to the outcome; hypothesis check one line each (confirmed / contradicted / unresolved); "Open with" a single recommended opening line, verbatim, calibrated to attendee posture.
- Company Snapshot: industry, size bucket, revenue range, HQ, website, business model. One paragraph weaving in strategic priorities and current challenges.
- Signals Worth Raising: grouped by category (funding and M&A, hiring direction, tech stack overlap or gaps, recent business events, voice on LinkedIn or site changes, competitive context, parent / subsidiary). For any past date inline: "Verify; date is in the past."
- Attendees: per attendee, name and title, department (fallback "Unattributed" when null), canonical seniority display (c-suite, vice president, director, manager), email, phone, LinkedIn, time in role, posture (Cold / Warm-but-dormant / Active / Hostile). "Why they matter for THIS meeting": 2 lines max. Talking points for them: 1-2 specific. If profile data is thin: "Profile data restricted; verify externally."
- Talking Points (3-5): ranked by impact, tagged for audience, each referencing a supporting data point with its source category tag. Prioritize items that show homework, connect to the offering, surface competitive angles, or hit a specific persona.
- Discovery Questions (3-5): specific, anchored in concrete facts. Tag each for an attendee or the group.
- Suggested Agenda (~30 min): (0-5) Open with the calibrated line; (5-15) Explore with the top talking point and 2 questions; (15-25) Develop with the secondary point, demo, or proposal; (25-30) Close on the specific desired next step.
- What NOT to Do: 1-3 specific failure modes for THIS meeting. Concrete, not generic.
Limitations
- Strategic insights and stated challenges are sourced from SEC 10-K filings: for private companies these will be all-null, and for public companies they can be 12-18 months stale. Use business events, funding, workforce trends, and recent posts for current-state signals.
- Business event fetching supports a date floor but no upper bound; window the upper edge client-side.
- Company size and revenue are bucketed. State buckets verbatim; do not interpolate exact figures.
- No native CRM relationship history or deal-stage data. Posture must be inferred from profile history and post voice, plus user-supplied context.
- No executive-move event enum. New-hire / departure signals must be inferred from workforce trends and profile changes, not fetched as a typed event.
- Past-dated milestones must be verified externally; treat them as prompts to check, not ground truth.
- Attendees who cannot be matched should be listed as unresolved. Do not synthesize their roles.
- Department is null for many cross-functional senior roles (Chief X Officer, President, Founder). Group these under "Unattributed".
Personalize Email
Gather every personalization signal for a single prospect and their company so the calling model can write a sharp, specific email. This skill does NOT draft the email: it returns a structured brief; the calling model composes copy.
Input
- Prospect identifier (required): full name + company, full name + company domain, LinkedIn URL, email, or a role at a company ("CFO at Notion") with no name.
- Use case (default
cold_outbound): one ofcold_outbound,discovery_follow_up,demo_recap,re_engagement,renewal,expansion,objection_handling. Drives which signals matter most. - Recency floor (optional): days. Defaults: 14 for intent topics, 30 for executive moves, 90 for company events.
- Sender / offering note (optional): one line on what the user sells, used only to rank signals.
- Prior touchpoint summary (optional, recommended for follow-up, recap, renewal): what was last discussed, when, who was involved.
Workflow
- Resolve the prospect. If a LinkedIn URL or email is supplied, match the person directly. Otherwise match the business first to anchor the company, then match the person by full name plus the resolved company. On miss, retry first plus last name. Capture prospect_id, business_id, full_name, job_title, linkedin_url. If either id fails, stop and surface the gap.
- Resolve-by-role path (the user named a seat, not a person). Matching by full_name="CFO" silently returns nothing: do NOT use that path. Instead match the business, then sample prospects at that account filtered by canonical job title and seniority. This is the dominant cold-outbound shape when the user knows the seat but not the person.
- Domain-variant sanity check at match time. After firmographics land, if the input was a major brand but the resolved entity has headcount 1-50 and looks like a registered-agent shell, retry with the alternate domain (.so vs .com) or the company-name string. Do not proceed with the wrong account.
- Discover canonical values for any free-text dimension the user named (industry, technology, city) before applying a filter. Show top matches and wait for the user to pick.
- Enrich the company. Firmographics first (industry, size, headcount, revenue range, HQ, age). Then pull recent signals broadly: funding and acquisitions, workforce trends, LinkedIn posts, website changes, stated challenges and strategic priorities. Add technographics only when the offering implies a tech-stack pitch. Add competitive landscape only for objection_handling or competitive displacement framing.
- Fetch business events on the last 90 days. Keep every event with a date; drop those older than the use-case recency floor during scoring. Event-attribution sanity check: ensure events tie to the matched business, not blended across a parent / subsidiary tree.
- Enrich the prospect. Profile (seniority, department, tenure in seat, last 2 prior employers). Pull contacts only when the user intends to send outreach: default email-only (cheaper), switch to email + phone only when phone is required (SDR dialer flows). Skip contacts entirely otherwise. Fetch prospect events for job-change or promotion moves. Per-prospect post history is a current gap; pull the employer's recent posts as a substitute for company voice.
- Score and rank signals. Stamp each with age in days and a source tag. Score recency x persona relevance x use-case fit. Recency: 0-14d = 1.0, 15-30d = 0.7, 31-60d = 0.4, 61-90d = 0.2, older = drop. Persona: CFO maps to funding / earnings / M&A; CRO and VP Sales map to hiring surges, product launches, GTM posts; CTO and VP Eng map to website changes, technographics, engineering hires; CEO maps to all. Use case: cold outbound and re-engagement lean on fresh events; follow-up, recap, renewal, expansion lean on prior touchpoint plus role and company posts; objection handling leans on competitive landscape and strategic insights. Rank top 5; mark the highest
anchor_candidate, nextrunner_up. - Build the persona cue block. Seniority, department, tenure in seat, last 2 prior employers. Tone hint by seat: executive (outcome first, numeric), director / manager (problem then approach then outcome), IC (workflow friction then concrete benefit). Pull 1-3 direct quotes or themes from recent posts when available.
- Assemble the proof hook list. Suggest peer-segment framings by industry and size band. Do not invent customer names or stats; flag only categories where the calling model could later plug real customer proof.
- Flag gaps and refuse conditions. For cold_outbound or re_engagement, if zero events pass the recency floor and zero relevant posts exist, mark
signal_layer: thinand recommend warming via another channel. For follow-up family without a prior touchpoint summary, surface the gap and ask; do not fabricate. If profile last update is older than 12 months or the resolved company does not match the user-named company, addstale_record: trueand recommend verifying.
Output Format
- TL;DR: one paragraph with prospect name, title, company, the single strongest anchor signal with age, and the persona tone hint.
- Prospect: full name, job title, company name, company domain, LinkedIn URL, prospect_id, business_id, email (only if contacts were pulled).
- Company snapshot: 2-4 lines covering industry, size bucket, headcount, revenue range, HQ, founding year.
- Signal ladder (ranked): for each of the top 5, rank, signal type, age in days, source tag, one-line description, why it matters for this persona and use case, anchor / runner-up flag.
- Persona cues: seniority, department, tenure in seat, last 2 prior employers, tone hint, direct quotes or post themes (up to 3, with date).
- Proof hook categories: peer-segment framings the calling model could plug real customer proof into. No invented stats or logos.
- Brief for the drafting model: compact structured block with anchor and age, runner-up, persona block, company block, chosen use case, gaps, and an explicit "do_not_invent" list (customer names, stats not in this brief).
- Flags:
signal_layer(rich | moderate | thin),stale_record,missing_prior_touchpoint(only for follow-up family),competitor_mention_detected.
Limitations
- Funding and acquisition data has coverage gaps for late-stage privates with no S-1. For CFO personas at private targets, lean on business events (M&A, new funding round, cost cutting, hiring in finance) instead.
- No native sort by signal recency at the API level; ranking is done client-side.
- No metro taxonomy; location filtering relies on city autocomplete plus country code.
- No similar-companies tool; peer framing falls back to industry plus size band.
- Headcount and revenue are buckets, not exact values.
- This skill does not draft email copy. The calling model writes subject lines and bodies from the brief.
- Per-prospect post history is not available; flag as a gap when the use case wants the individual's posting voice.
- Department is null for many cross-functional senior roles (Chief X Officer, President, Founder). Group these under "Unattributed" in the persona cue block.
Score Leads
Gather verified person, account, and trigger evidence per lead so a downstream model can tier leads Hot / Warm / Cold against a stated persona and ICP. This skill collects the evidence and restates the rule set; it does NOT apply scoring math.
Input
- Leads (required): list of prospect IDs, emails, LinkedIn URLs, or name+company rows. Mixed types allowed.
- Buyer persona (required): target job titles or title keywords, seniority, and department.
- ICP (required): country (or region-country), company size buckets, optional revenue buckets, optional industry (LinkedIn or NAICS, mutually exclusive), optional tech stack, optional company age.
- Source label per lead (optional): e.g. demo_request, pricing_inquiry, free_trial, content_download, webinar_attended, cold_inbound. Passed through verbatim.
- Tier thresholds (optional): Hot and Warm cutoffs on the composite the caller computes.
- Trigger lookback (optional): default 90 days for recent business events.
Workflow
- Lock the persona and ICP rule set. Restate persona (titles, seniority, department) and the ICP filter shape. Discover canonical values for every free-text dimension (industry, tech stack, job title, city) before applying any filter. Tighten persona matches by intersecting a job-title filter with a seniority filter: a title-only filter is loose and returns near-matches at the rim. Note the mutually exclusive choices (LinkedIn vs NAICS; country vs region-country). Echo persona and ICP in the output so scoring math is auditable.
- Resolve each lead. Bucket every input row; never silently drop one. Known prospect IDs pass through. Email rows resolve by email: email is a unique identifier, so a no-match is a hard fail, NOT a fallback to name search (a typo'd email must not silently resolve to a different real person). LinkedIn URL rows resolve by URL. Name+company rows resolve by full name plus company name or domain: person matching returns only an id or null (no confidence score, no candidate list), so a name+company match at a 10k+ employee company is indistinguishable from a unique email match. Treat name+company matches as Verified-with-caveat by default. Free-text rows like "Jane Doe at Acme" parse to the name+company path. Persona-only rows (no name, "the CFO at Notion") must NOT use full_name="CFO" (silently returns nothing); instead match the business, then sample prospects at that account filtered by canonical job title and seniority, and surface the candidates as Verified (caveat) for the user to pick. Tag each row: Auto-resolved, Verified (caveat), Ambiguous (pause), or Failed (no match). Never reroute Failed emails into name search.
- Enrich the person. Profile (full name, title, seniority, department, linkedin URL) plus contacts. Default email-only (cheaper); switch to email + phone only when phone is required (SDR dialer flows). Per-prospect post history is a current gap; if recent activity matters, pull the employer's recent posts as a substitute.
- Resolve and enrich the lead's company. Match the business by domain or name, then enrich firmographics (headcount, revenue range, country, industry, size bucket, age, description). Add technographics when the ICP names a tech stack. Add funding posture when the ICP cares about stage.
- Fetch recent triggers per account on the configured lookback (default 90 days). Relevant events: new funding rounds, leadership hires in the persona's department, hiring surges in the persona's department, office openings or relocations, product launches, new partnerships. For accounts where prospect-level moves matter (job change into the persona seat), also fetch prospect events. Tag each event with age in days. Event-attribution sanity check: ensure events tie to the matched business, not blended across parent / subsidiary entities.
- Optional ICP corroboration. If the caller wants to know whether the lead's account looks like the broader ICP shape, size the ICP filter set once and attach the summary (total addressable count, size bucket distribution, top industries). Do not re-pull per lead.
- Compose one evidence row per lead. Each row carries: input identifier, resolution status, person id, full name, title, mapped seniority (canonical), mapped department, email, phone, linkedin URL, company name, company domain, business id, headcount, revenue range, country, industry, size bucket, revenue bucket, tech stack hits (only those intersecting the ICP tech list), top 3 recent events (type, age in days, one-line summary), source label, caveat strings (Stale, Ambiguous, Failed, Missing phone, Email not found). Process in chunks of ~25 end-to-end so working context does not balloon.
- State the scoring boundary explicitly. The output ships the per-lead evidence plus the rule set verbatim. Composite scoring and tier assignment (Hot / Warm / Cold) are the caller's job. Do not invent a composite score in this skill.
Output Format
- Restated rules: persona (titles, seniority set, department set); ICP filter set (exact object with canonical-resolved values, plus the industry-taxonomy and country-vs-region choices); trigger lookback in days.
- Resolution summary: one row per input with input, resolved name, person id, status. Status legend: Auto-resolved, Verified (caveat), Ambiguous, Failed.
- Per-lead evidence rows: one row per lead with the columns from step 7.
- ICP shape (optional, when corroboration ran): total addressable count, top size buckets, top industries.
- Scoring rules handed to the caller: persona-match rule (title list, seniority set, department set), ICP-match rule (the filter object), source weights (or raw label pass-through), trigger weights (event-type weights and recency decay), tier thresholds (Hot and Warm cutoffs).
- Caveats: Failed leads are not scoreable, list separately; stale records (>12 months) get a "downweight title-based fit" flag; Hot-candidate leads missing both phone and professional email get a "verify contact data before outreach" flag.
Limitations
- Scoring math is downstream LLM work. This skill gathers evidence and restates the rule set; it does NOT produce a composite score or assign a tier.
- Name+company resolution can return multiple plausible matches at large companies; those rows surface as Ambiguous, and the matching response carries no confidence signal to disambiguate.
- Company size and revenue are bucketed, not exact counts; persona/ICP math must work against the bucket.
- Industry taxonomy (LinkedIn vs NAICS) is mutually exclusive on a single ICP filter.
- No built-in scoring engine, no contact data-quality sort, no native employee or revenue sort, no Inc/Fortune ranking signal, no metro taxonomy, no sub-department job-function filter.
- Department is null for many cross-functional senior roles (Chief X Officer, President, Founder). Group these under "Unattributed".
- The mapped seniority column should show the canonical value used for filtering.
Talent Mapping
Map who does a given job across a set of companies, and where that talent is most likely to move, before a single outreach goes out.
Input
$ARGUMENTS describes:
- A function or role family to map (required): "data engineering", "enterprise sales", "product design leadership".
- A company set (required): named companies or domains, a competitor list, or a company profile ("Series C-E cybersecurity in the US, 200-1000 employees").
- Optional seniority focus (default Manager and above plus senior ICs).
- Optional geography.
- Optional depth: "overview" (counts and leaders only, default) or "full" (named roster per company).
Setup check (always do this first)
This skill runs on Explorium's B2B data through Vibe Prospecting. Before step 1, confirm a data path is available:
- MCP / connector: a Vibe Prospecting tool such as
fetch-entitiesormatch-businessis in your tool list. If it is, proceed. - CLI fallback: run
npx @vibeprospecting/vpai@latest --help. If it lists tools, proceed. If it errors on auth, ask the user to runnpx @vibeprospecting/vpai@latest config --api-key "YOUR_VP_API_KEY". - Neither available: stop and tell the user: "Please connect the Vibe Prospecting connector (https://vibeprospecting.explorium.ai/mcp) or configure the CLI, then let me know." Do not continue or invent data.
Workflow
-
Resolve the company set. Match each named company and sanity-check firmographics: a major brand resolving to 1-50 employees in a Corporate-Managing-Offices category likely routed to a shell entity, so retry with the alternate domain. For a profile instead of names, size it first and cap the map at 15 companies; if more match, ask the user to tighten or pick. Surface ambiguous matches for confirmation rather than picking silently.
-
Define the role family. Translate the function into a department value plus 4 to 8 discovered canonical titles spanning the ladder (IC, senior IC, manager, director, VP, C-level). Confirm the family with the user, since "data" alone can mean analytics, engineering, or science.
-
Count before you pull. For each company, get the match count by seniority band for the role family. This is cheap and produces the bench-size view even when the user only wants an overview.
-
Pull leaders, sample ICs. For every company, materialize the people at Director and above in the role family. For "full" depth, also materialize senior ICs and managers up to 50 per company. Pair every title filter with a seniority value: title-only filters leak.
-
Enrich profiles. Pull profile data for the materialized people to get tenure in current role, time at company, and prior employers. Skip contact enrichment: a talent map is research. Point the user to
talent-sourcingorenrich-contactwhen they move to outreach. -
Collect movement signals.
- Company level, last 180 days: business events for layoffs, leadership changes, acquisitions or mergers, office closures, and funding rounds. Verify each headline names the target company: industry-wide articles can cross-attribute.
- Workforce trend: headcount change in the last 6 and 12 months, and department-level trend for the mapped function where available.
- People level: prospect events for recent role changes among the mapped leaders.
-
Score each company as a talent source (0-100):
- Bench depth (35): count of people in the role family at the target seniority, relative to the other companies in the set.
- Movement pressure (40): layoff or restructuring = 90-100; new leadership in the mapped function in the last 6 months = 70-85; acquisition = 70; declining headcount = 50-70; flat = 30; strong growth or fresh large round = 10-20.
- Tenure ripeness (25): share of mapped people with 2-4 years in role.
Explain the score in one line. Do not score individuals here; that belongs to
talent-sourcing.
Output Format
Map Scope
Role family (department plus titles), seniority bands, geography, and the resolved company list with domain, industry, and headcount bucket. Note any company that failed to resolve.
Talent Source Ranking
| Rank | Company | Bench Size (role family) | Directors+ | Headcount Trend 12m | Key Movement Signal | Source Score | Why |
|---|
Company Maps
One block per company, ordered by source score:
- Bench by seniority: counts per band.
- Leadership: name, title, tenure in role, prior employer, LinkedIn. Flag leaders who joined in the last 6 months (team reshuffles often follow).
- Notable ICs (full depth only): name, title, tenure, LinkedIn.
- Signals: dated events with a one-line summary.
Market Read
3 to 6 bullets: where the deepest benches sit, which companies show the most pressure right now, common prior-employer feeder companies seen across the map, and typical tenure. Flag companies to avoid (client conflicts, strong growth making talent hard to move).
Next Steps
- Run
talent-sourcingscoped to the top 3 source companies to build a ranked candidate pipeline. - Re-run in 60-90 days to catch new movement signals.
- Expand the set with
lookalike-accountsseeded on the highest-scoring source company.
Fair-hiring and privacy rules
- Map roles and companies, not personal characteristics. Never segment or comment on protected characteristics or proxies for them.
- Keep the map to professional, publicly listed information. Do not pull personal contact data during mapping.
- When the user names companies under a no-poach or client agreement, exclude them and say so in Map Scope.
Limitations
- Requires the Vibe Prospecting connector or CLI; data coverage and credits follow the user's Vibe Prospecting plan.
- Counts reflect people whose professional profiles match the role family. Small or stealth teams, and people with sparse profiles, are undercounted.
- No department-level headcount history for every company: when missing, fall back to company-wide headcount trend and say so.
- No executive-departure event type. Leavers show up only indirectly, via new-joiner signals at other companies or role-change events.
- No sub-department job-function filter. The finest cut is department plus discovered titles.
- Title filters are loose: always pair with seniority.
- Large companies can return thousands of matches: the map caps named rosters at 50 per company and relies on counts beyond that.
Talent Sourcing
Turn a role brief into a ranked, contactable pipeline of passive candidates, with a transparent fit score per person.
Input
$ARGUMENTS is a job description, a pasted JD link's text, or a free-text brief. Parse it for:
- Target role: title, seniority, department / function.
- Must-haves vs nice-to-haves. If the brief does not separate them, propose a split and confirm before searching.
- Source-company profile: industry, size bucket, stage, tech stack, or a named list of target companies ("ex-Stripe, Adyen, or Checkout.com").
- Exclusions: current employer, clients under a no-poach agreement, companies the user names.
- Geography: country, state, city region, or "remote in [country]".
- Pipeline size (default 30, max 150) and whether contact data is needed now or later.
Example phrasings: "Senior backend engineers, Go + Kafka, at Series B-D fintechs in Germany", "VP Sales for a 200-person SaaS company, must have scaled a team from 10 to 50", "Head of RevOps, ex-HubSpot or Salesforce customer, US remote, exclude our clients", "30 product designers at consumer apps in London".
Setup check (always do this first)
This skill runs on Explorium's B2B data through Vibe Prospecting. Before step 1, confirm a data path is available:
- MCP / connector: a Vibe Prospecting tool such as
fetch-entitiesormatch-businessis in your tool list. If it is, proceed. - CLI fallback: run
npx @vibeprospecting/vpai@latest --help. If it lists tools, proceed. If it errors on auth, ask the user to runnpx @vibeprospecting/vpai@latest config --api-key "YOUR_VP_API_KEY". - Neither available: stop and tell the user: "Please connect the Vibe Prospecting connector (https://vibeprospecting.explorium.ai/mcp) or configure the CLI, then let me know." Do not continue or invent data.
Workflow
-
Build the search blueprint. Translate the brief into a candidate profile (titles, seniority, department, geography) and a source-company profile (industry, size, stage, tech, named companies). Expand the target title into 3 to 6 adjacent titles a strong candidate might hold today ("Staff Engineer", "Senior Software Engineer, Payments", "Tech Lead"). Note one level down in seniority as a "step-up" pool when the role is a promotion move for most candidates. Show the blueprint and confirm before any fetch.
-
Discover canonical values. Resolve every free-text token (job titles, industries, technologies, city regions) to the standardized values the API expects. Skip discovery for ISO country codes, region codes, size and revenue buckets, seniority and department enums.
-
Resolve the source companies. When the user names target companies, match each one and sanity-check the firmographics: a well-known brand returning 1-50 employees in a Corporate-Managing-Offices category is likely a shell entity, so retry with the alternate domain. When the user describes a company profile instead, build a businesses table from those filters first and thread it into the prospect fetch. Remove excluded companies at this stage.
-
Tighten loose title filters. Title filters are not exact-match: always pair a title with a seniority value, and with a department when the title is generic ("Manager", "Lead").
-
Size the pool. Get a total match count. Under 20: suggest broadening (adjacent titles, wider geography, step-up pool). Over 2,000: suggest tightening (narrower company profile, tech stack, seniority). Report the number honestly.
-
Sample-first preview. Pull 5 candidates and render them for the user to sanity-check the translation. Wait for approval before materializing the full pipeline.
-
Materialize and enrich. Pull the full pipeline. Enrich every row with profile data (work history, tenure in current role, prior employers, education where available). Defer contact enrichment until the user confirms they are ready to reach out; then default to professional email, and add personal email or phone only when the user explicitly asks.
-
Check recent movement. Fetch prospect events on the pipeline to flag recent role changes. Someone who changed jobs in the last 6 months is rarely movable: mark them, do not drop them. Fetch business events on their employers for the last 90 days: layoffs, leadership changes, acquisitions, and funding drought raise openness to a move; a fresh large funding round lowers it.
-
Score and rank. Score each candidate 0-100:
- Must-have fit (50): title, seniority, function, and any must-have that can be evidenced from profile data. A candidate missing a must-have caps at 49.
- Nice-to-have fit (20): source-company match, tech stack of employer, career trajectory (promotions, scope growth).
- Movability (20): tenure in role 2-4 years = high; under 12 months = low; 5+ years = medium. Employer-level signals from step 8 adjust up or down.
- Reachability (10): professional email, then personal email, then LinkedIn only. Break ties by must-have fit, then movability.
Output Format
Role Blueprint
Bullets: target and adjacent titles, seniority (plus step-up pool if used), function, geography, source-company profile, exclusions, and the must-have / nice-to-have split as confirmed.
Candidate Pipeline
| Rank | Name | Current Title | Current Company | Tenure In Role | Prior Employers | Location | Score | Movability | Why They Fit |
|---|
"Why They Fit" is one clause tied to the brief ("Scaled SDR team at a Series C fintech; Kafka shop"). Leave Email blank until contact enrichment runs.
Pool Read
Total matching pool from step 5, rows returned, score distribution (80+, 60-79, under 60), breakdown by source company and by location. Flag gaps: a must-have no candidate evidences, a target company with zero matches, or a geography that is too thin.
Top 10 To Contact First
One line each: why now (tenure, employer event) and a suggested outreach angle drawn from their trajectory, not generic praise.
Next Steps
- Run contact enrichment on the top tier once outreach is approved.
- Run
talent-mappingon the strongest source companies to see the full bench there. - Pass the top 10 to
contact-researchfor a per-person synopsis before outreach. - Re-run with the step-up pool or adjacent geography to widen a thin pipeline.
Fair-hiring and privacy rules
- Never filter, score, or comment on protected characteristics (age, gender, ethnicity, religion, disability, nationality, family status) or proxies for them, such as graduation year used to infer age or names used to infer gender or origin. If the brief asks for this, decline that criterion and say why.
- Score only on job-related evidence present in the data. Do not infer skills the profile does not show; mark them "unverified" instead.
- Use contact data only for recruiting outreach about a real role. Remind the user to honor opt-outs and local rules (GDPR, CCPA) on candidate data.
Limitations
- Requires the Vibe Prospecting connector or CLI; data coverage and credits follow the user's Vibe Prospecting plan.
- Profile data reflects what candidates publish professionally. Skills, scope, and team size are often missing: treat absence as unknown, not as a gap.
- No native skills or certifications filter. Approximate with title tokens, department, and employer tech stack.
- No sub-department job-function filter. Combine discovered titles with department.
- Title filters are loose: always pair with seniority.
- Headcount and revenue are bucketed, so source-company size cuts are approximate.
- The preview is capped at 5 rows. The full pipeline materializes only after approval.
- Compensation, visa status, and job-seeking intent are not available.
MCP servers 1
Sponsors
Details
- Marketplace
- explorium-ai/gtm-skills
- Category
- Marketing
- License
- MIT
- Keywords
- b2b, prospecting, enrichment, gtm, outbound, sales, lead-generation, lead-gen-tool, crm-enrichment, buying-signals, waterfall-enrichment, entity-matching, contact-enrichment, company-enrichment, account-research, mcp, claude-code, codex, abm, marketing, linkedin-ads, zoominfo-alternative