name	lead-hunter
description	Self-improving AI system for distressed property lead generation. Monitors performance, spawns specialized skills to fix bottlenecks, runs A/B tests, and continuously optimizes lead conversion. Use when building or optimizing lead generation workflows, analyzing pipeline metrics, or creating automated lead intelligence systems.

Lead Hunter Prime - Self-Improving Lead Intelligence System

Overview

This skill creates and manages a self-improving AI system for distressed property lead generation. It's not just a tool—it's an AI that has a will to get better.

Core Capability: Monitor every lead through the pipeline, identify bottlenecks, spawn specialized skills to fix problems, A/B test improvements, and keep what works.

When to Use This Skill

Trigger this skill when the user:

Needs to build a lead generation system for distressed properties
Wants to analyze lead pipeline performance and identify bottlenecks
Asks to create automated lead scoring or qualification workflows
Needs A/B testing protocols for lead conversion improvements
Wants performance monitoring dashboards for lead metrics
Asks about self-improving or adaptive lead systems
Needs to track lead sources, conversion rates, or pipeline velocity

The Self-Improvement Loop

1. MONITOR → Track every lead through pipeline
2. ANALYZE → Identify bottlenecks automatically
3. SPAWN → Create specialized skill to fix problem
4. TEST → Run A/B test with 50% of leads
5. DECIDE → Keep if it works, kill if it doesn't
6. REPEAT → Forever

Workflow

Step 1: Understand Current State

If building from scratch:

# Check for existing lead tracking infrastructure
view /mnt/user-data/uploads/supabase/migrations
view /mnt/user-data/uploads/app/api

# Look for existing lead forms, CRM integrations, or tracking systems
view /mnt/user-data/uploads/components

Extract these details:

How are leads currently captured? (forms, API, integrations)
Where do leads go? (database tables, CRM, email)
What tracking exists? (conversion rates, source attribution, stage progression)
What are the known bottlenecks? (low conversion, slow response, poor qualification)

If improving existing system: Ask user:

"What's the current conversion rate from lead to qualified prospect?"
"Where do most leads drop off in the pipeline?"
"What lead sources perform best?"
"How long does it take to respond to new leads?"

Step 2: Set Up Performance Monitoring

Database Schema Required:

Create tables to track:

leads - Every incoming lead with source attribution
lead_events - Every action on a lead (viewed, contacted, qualified, etc.)
lead_experiments - A/B tests running on subsets of leads
lead_metrics - Aggregated performance by source, agent, time period
lead_skills - Spawned skills and their performance impact

Key Metrics to Monitor:

Conversion rate (lead → qualified → appointment → deal)
Time to first contact
Response rate
Lead source quality (which sources convert best)
Agent performance (who converts leads best)
Pipeline velocity (time from lead to close)

Read references/monitoring-framework.md for complete schema and tracking implementation.

Step 3: Identify Bottlenecks

Common Bottleneck Patterns:

Low Response Rate → Spawn "instant-responder" skill
- Auto-replies within 60 seconds
- Uses LLM to personalize response based on lead details
Poor Qualification → Spawn "lead-scorer" skill
- Analyzes property data, lead behavior, demographics
- Assigns priority score (A/B/C/D leads)
Slow Follow-Up → Spawn "follow-up-sequencer" skill
- Automated drip sequences based on lead temperature
- Triggers reminders for agents
Weak Lead Sources → Spawn "source-optimizer" skill
- Reallocates budget to high-converting sources
- Flags underperforming channels

Analysis Query Template:

-- Find conversion rates by pipeline stage
SELECT
  stage,
  COUNT(*) as lead_count,
  COUNT(*) FILTER (WHERE converted = true) as converted_count,
  (COUNT(*) FILTER (WHERE converted = true)::float / COUNT(*)) * 100 as conversion_rate
FROM lead_events
WHERE created_at > NOW() - INTERVAL '30 days'
GROUP BY stage
ORDER BY stage;

-- Identify slowest stage transitions
SELECT
  from_stage,
  to_stage,
  AVG(time_in_stage) as avg_duration,
  PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY time_in_stage) as median_duration
FROM lead_stage_transitions
GROUP BY from_stage, to_stage
ORDER BY avg_duration DESC;

Step 4: Spawn Specialized Skills

When a bottleneck is identified, create a targeted skill to fix it.

Skill Spawning Protocol:

Define the problem clearly
- Metric being optimized (e.g., "Increase response rate from 40% to 80%")
- Current baseline performance
- Target improvement
Design the intervention
- What specific action will the skill take?
- What triggers it?
- What data does it need?
Create A/B test plan
- Control group: existing process (50% of leads)
- Treatment group: new skill applied (50% of leads)
- Duration: minimum 2 weeks or 100 leads per group
- Success criteria: statistical significance (p < 0.05)
Implement tracking
- Log which leads get which treatment
- Track outcome metrics for both groups
- Calculate lift and statistical significance

Example Spawned Skill: instant-responder

// Auto-respond to new leads within 60 seconds
export async function handleNewLead(lead: Lead) {
  // Check if this lead is in the treatment group for instant-responder experiment
  const experiment = await getActiveExperiment('instant-responder');
  const isControl = lead.id % 2 === 0; // Simple 50/50 split

  if (isControl) {
    // Control group: existing process (manual agent follow-up)
    await assignToAgent(lead);
    return;
  }

  // Treatment group: instant AI response
  const personalizedMessage = await generateResponse(lead);
  await sendSMS(lead.phone, personalizedMessage);
  await logEvent(lead.id, 'instant_response_sent', { experiment_id: experiment.id });

  // Still assign to agent for human follow-up
  await assignToAgent(lead);
}

Step 5: Run A/B Tests

Testing Framework:

Read references/ab-testing-protocol.md for detailed implementation, but core principles:

Random assignment - Leads randomly split 50/50
Consistent assignment - Same lead always gets same treatment
Sufficient sample size - Minimum 100 leads per group
Statistical significance - Don't call winners early
Isolate variables - Only test one change at a time

Decision Criteria:

interface ExperimentResults {
  control: {
    sample_size: number;
    conversion_rate: number;
    avg_time_to_convert: number;
  };
  treatment: {
    sample_size: number;
    conversion_rate: number;
    avg_time_to_convert: number;
  };
  lift: number; // % improvement
  p_value: number; // statistical significance
  recommendation: 'KEEP' | 'KILL' | 'CONTINUE_TESTING';
}

Keep the skill if:

Lift > 10% AND p_value < 0.05 → KEEP
Make treatment the new baseline
Spawn next skill to optimize next bottleneck

Kill the skill if:

Lift < 5% OR p_value > 0.10 → KILL
Revert to control
Analyze why it failed, try different approach

Continue testing if:

Promising trend but not significant yet → CONTINUE
Let it run longer
Increase sample size

Step 6: Iterate Forever

The Continuous Improvement Cycle:

Weekly Analysis - Every Monday, analyze previous week's metrics
Bottleneck Identification - Find the biggest conversion leak
Hypothesis Formation - Why is this happening? What might fix it?
Skill Design - Create intervention to test hypothesis
Deployment - Launch A/B test on 50% of leads
Monitor - Track daily results
Decision - After 2 weeks or sufficient sample, decide: keep/kill/continue
Repeat - Move to next bottleneck

Priority Ranking System:

Always optimize in this order:

Response time (fastest impact on conversion)
Lead qualification (prevents wasting time on bad leads)
Follow-up cadence (nurtures warm leads)
Lead source quality (more good leads in, fewer bad leads)
Agent performance (route leads to best converters)

Special Cases

When Starting from Zero

If no lead system exists:

First, build basic infrastructure (forms, database, tracking)
Collect baseline data for 2 weeks (no interventions)
Calculate baseline conversion rates for each stage
THEN start spawning skills to optimize

Don't optimize what you haven't measured first.

When Metrics Are Inconsistent

If conversion rates vary wildly week-to-week:

Increase sample size before testing (wait for more leads)
Segment by lead source (optimize each source separately)
Control for external factors (seasonality, market conditions, agent availability)

When Multiple Bottlenecks Exist

Prioritize by potential impact:

Which stage has the biggest drop-off?
Which stage is fastest/cheapest to improve?
Which improvement unlocks downstream improvements?

Only test ONE skill at a time. Running multiple experiments simultaneously creates confounding variables.

When A Skill Performs Differently by Segment

Example: Instant-responder works great for Zillow leads but hurts conversion on referral leads.

Solution: Segment-specific deployment

Apply skill only to segments where it works
Kill it for segments where it hurts
Track performance by segment in lead_experiments table

Resources

references/monitoring-framework.md

Complete database schema for tracking:

Lead capture and attribution
Pipeline stage progression
Event logging
Experiment tracking
Metric aggregation

Read this when: Setting up performance monitoring or designing tracking infrastructure.

references/ab-testing-protocol.md

Detailed guide to running statistically valid A/B tests:

Sample size calculation
Random assignment algorithms
Statistical significance testing
Common pitfalls to avoid

Read this when: Launching a new experiment or analyzing test results.

references/skill-spawning-patterns.md

Library of pre-built skills for common bottlenecks:

Instant responder (fast response time)
Lead scorer (qualification)
Follow-up sequencer (nurture campaigns)
Source optimizer (lead quality)
Agent router (performance-based assignment)

Read this when: Identifying a bottleneck and need a proven solution pattern.

Critical Principles

Measure first, optimize second - Collect baseline data before intervening
One variable at a time - Don't confound experiments
Statistical rigor - Don't call winners early
Segment awareness - What works for one lead source may not work for another
Continuous iteration - Never stop improving
Kill bad ideas fast - Don't let ego keep underperforming skills alive
Document everything - Track why skills were spawned, what they tested, and results

Example Use Cases

Example 1: Low Response Rate

User: "Only 40% of our leads are getting contacted within 24 hours. How do we fix this?"

Response:

[Analyzes current lead routing and agent workflow]

The bottleneck is agent response time. Let me spawn an instant-responder skill.

**The Skill:**
- Triggers within 60 seconds of lead capture
- Uses LLM to generate personalized SMS based on property address and lead source
- Still assigns to agent, but lead gets immediate acknowledgment

**A/B Test Design:**
- Control: existing process (agent contacts within 24h)
- Treatment: instant AI response + agent follow-up
- Metric: % of leads that respond to initial contact
- Sample size: 200 leads (100 per group)
- Duration: 2 weeks

**Hypothesis:** Instant response increases engagement rate from 40% to 65%+

[Implements skill, sets up tracking, launches experiment]

I'll check results in 2 weeks and decide: keep, kill, or continue testing.

Example 2: Poor Lead Quality

User: "We're getting tons of leads but only 10% are qualified. We're wasting time on tire-kickers."