AI Lead Generation: Build a System That Runs Itself

// qualifier.ts
import Anthropic from "@anthropic-ai/sdk";

export interface Lead {
  name: string;
  title: string;
  company: string;
  companySize?: string;
  industry?: string;
  linkedinUrl?: string;
  email?: string;
  companyWebsite?: string;
}

export interface QualificationResult {
  qualified: boolean;
  score: number; // 0-100
  reasons: string[];
  disqualifyReasons: string[];
  suggestedAngle: string;
}

const anthropic = new Anthropic();

// Define your ideal customer profile
const ICP = `
Ideal Customer Profile:
- Company size: 20-500 employees
- Industry: B2B SaaS, Professional Services, or E-commerce
- Role: Founder, CEO, VP of Sales, Head of Marketing
- Pain points: Manual processes, scaling challenges, team efficiency
- NOT a fit: Enterprise companies (500+), B2C, Government, Non-profit
`;

export async function qualifyLead(lead: Lead): Promise<QualificationResult> {
  const response = await anthropic.messages.create({
    model: "claude-haiku-4-20250514",
    max_tokens: 512,
    system: `You are a sales qualification expert. Evaluate leads against our ICP and return JSON.
${ICP}
Return: { qualified: boolean, score: 0-100, reasons: string[], disqualifyReasons: string[], suggestedAngle: string }`,
    messages: [
      {
        role: "user",
        content: `Lead: ${JSON.stringify(lead)}`,
      },
    ],
  });

  const text = response.content[0].type === "text" ? response.content[0].text : "{}";

  try {
    return JSON.parse(text);
  } catch {
    return { qualified: false, score: 0, reasons: [], disqualifyReasons: ["Parse error"], suggestedAngle: "" };
  }
}

// enricher.ts
import Anthropic from "@anthropic-ai/sdk";

export interface EnrichedLead extends Lead {
  companyDescription?: string;
  recentNews?: string[];
  techStack?: string[];
  estimatedRevenue?: string;
  fundingInfo?: string;
  companyPainPoints?: string[];
  personalTriggers?: string[]; // recent posts, articles, talks by the lead
}

async function fetchCompanyContext(website: string): Promise<string> {
  try {
    const response = await fetch(website, {
      signal: AbortSignal.timeout(5000),
    });
    const html = await response.text();
    // Simple extraction - in production use a proper scraper
    return html
      .replace(/<[^>]*>/g, " ")
      .replace(/\s+/g, " ")
      .slice(0, 3000);
  } catch {
    return "";
  }
}

const anthropic = new Anthropic();

export async function enrichLead(
  lead: Lead & { qualified: boolean; suggestedAngle: string }
): Promise<EnrichedLead> {
  // Fetch company context if we have their website
  const companyContext = lead.companyWebsite
    ? await fetchCompanyContext(lead.companyWebsite)
    : "";

  if (!companyContext) return lead;

  const response = await anthropic.messages.create({
    model: "claude-haiku-4-20250514",
    max_tokens: 1024,
    system: `Extract structured information from company website content. Return JSON only.
Extract: { companyDescription, techStack, companyPainPoints, estimatedRevenue }`,
    messages: [
      {
        role: "user",
        content: `Company: ${lead.company}\nWebsite content:\n${companyContext}`,
      },
    ],
  });

  const text = response.content[0].type === "text" ? response.content[0].text : "{}";

  try {
    const extracted = JSON.parse(text);
    return { ...lead, ...extracted };
  } catch {
    return lead;
  }
}

// email-generator.ts
import Anthropic from "@anthropic-ai/sdk";
import { EnrichedLead } from "./enricher.js";

export interface GeneratedEmail {
  subject: string;
  body: string;
  personalizationNotes: string; // for review purposes
  confidence: number; // 0-1, how confident the AI is this will resonate
}

const anthropic = new Anthropic();

const YOUR_CONTEXT = `
About us: We help B2B companies automate their operations with AI agents.
Key offer: We replace 3-5 manual processes with AI in 30 days, saving 10+ hours/week per process.
Proof: We've done this for 47 companies. Average ROI: 4.2x in 6 months.
CTA: 20-minute discovery call to map their automation opportunities.
`;

export async function generatePersonalizedEmail(
  lead: EnrichedLead & { suggestedAngle: string }
): Promise<GeneratedEmail> {
  const response = await anthropic.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 1024,
    system: `You are an expert B2B copywriter. Write cold emails that don't read like cold emails.

Principles:
- Lead with something specific to THEM (not a generic compliment)
- One clear point about what you do and why it matters to them
- One specific, low-friction CTA
- Under 150 words total
- No corporate language
- Sound like a smart person, not a marketing team

${YOUR_CONTEXT}`,
    messages: [
      {
        role: "user",
        content: `Write a cold email for this lead.

Recipient: ${lead.name}, ${lead.title} at ${lead.company}
Company context: ${lead.companyDescription || "B2B company"}
They likely care about: ${lead.companyPainPoints?.join(", ") || "efficiency and growth"}
Suggested angle: ${lead.suggestedAngle}

Return JSON: { subject, body, personalizationNotes, confidence }`,
      },
    ],
  });

  const text = response.content[0].type === "text" ? response.content[0].text : "{}";

  try {
    return JSON.parse(text);
  } catch {
    return {
      subject: `Quick question, ${lead.name}`,
      body: "Hi ${lead.name}, I'd love to learn more about what you're working on at ${lead.company}...",
      personalizationNotes: "Template fallback",
      confidence: 0.3,
    };
  }
}

// pipeline.ts
import * as dotenv from "dotenv";
dotenv.config();

import { Lead } from "./qualifier.js";
import { qualifyLead } from "./qualifier.js";
import { enrichLead } from "./enricher.js";
import { generatePersonalizedEmail } from "./email-generator.js";
import * as fs from "fs/promises";

// Configuration
const CONFIDENCE_THRESHOLD = 0.7; // Only send emails AI is 70%+ confident about
const MIN_QUALIFICATION_SCORE = 60; // 0-100 scale

async function processLead(lead: Lead): Promise<void> {
  console.log(`Processing: ${lead.name} at ${lead.company}`);

  // Step 1: Qualify
  const qualification = await qualifyLead(lead);
  console.log(`  Qualification score: ${qualification.score}`);

  if (!qualification.qualified || qualification.score < MIN_QUALIFICATION_SCORE) {
    console.log(`  SKIPPED: ${qualification.disqualifyReasons.join(", ")}`);
    return;
  }

  // Step 2: Enrich
  const enriched = await enrichLead({ ...lead, ...qualification });

  // Step 3: Generate email
  const email = await generatePersonalizedEmail(enriched);
  console.log(`  Email confidence: ${email.confidence}`);

  if (email.confidence < CONFIDENCE_THRESHOLD) {
    console.log(`  SKIPPED: Low confidence email (${email.confidence})`);
    // Could save to manual review queue instead
    return;
  }

  // Step 4: Save for review (or send directly if fully automated)
  const output = {
    lead: enriched,
    qualification,
    email,
    timestamp: new Date().toISOString(),
  };

  await fs.appendFile(
    "./output/ready-to-send.jsonl",
    JSON.stringify(output) + "\n"
  );

  console.log(`  READY: ${email.subject}`);
}

async function runPipeline(leads: Lead[]): Promise<void> {
  await fs.mkdir("./output", { recursive: true });

  console.log(`Processing ${leads.length} leads...\n`);

  for (const lead of leads) {
    await processLead(lead);
    // Rate limit: 1 second between leads
    await new Promise(resolve => setTimeout(resolve, 1000));
  }

  console.log("\nPipeline complete. Review ./output/ready-to-send.jsonl");
}

// Example leads - in production, fetch from Apollo, LinkedIn, Clearbit, etc.
const exampleLeads: Lead[] = [
  {
    name: "Sarah Chen",
    title: "VP of Operations",
    company: "Stackify",
    companySize: "85",
    industry: "SaaS",
    email: "sarah@stackify.com",
    companyWebsite: "https://stackify.com",
  },
];

runPipeline(exampleLeads).catch(console.error);