Your sales team runs the same campaigns for months.

"This email sequence works okay." "That call script converts about 3%." "LinkedIn outreach gets some responses."

Works okay is killing your pipeline.

The problem isn't that you don't test—it's that traditional A/B testing takes forever. By the time you reach statistical significance, the market has moved on.

What if you could run 10 tests in the time it currently takes to run one?

AI makes this possible. Here's how to build a system that continuously experiments, learns, and optimizes your outbound.

Why Traditional A/B Testing Fails for Sales​

The Volume Problem​

To reach 95% statistical significance with a 2% conversion rate and 0.5% lift, you need roughly 15,000 sends per variant.

Most sales teams don't send 30,000 emails in a quarter. They never get clean answers.

The Multivariate Problem​

You want to test:

• Subject line (5 variants)
• Opening line (4 variants)
• CTA (3 variants)
• Send time (4 variants)
• Personalization depth (3 variants)

That's 720 combinations. At 15K per test, you'd need 10.8 million sends to test everything.

Impossible.

The Time Problem​

Even if you had the volume, testing one thing at a time takes months:

• Test 1: Subject lines (6 weeks)
• Test 2: Opening lines (6 weeks)
• Test 3: CTAs (6 weeks)
• Test 4: Send times (6 weeks)

Six months later, you've tested 4 things. Your competitors have tested 40.

The AI-Powered Approach​

AI agents can:

1. Design smart tests — Focus on high-impact variables
2. Generate variants — Create dozens of options instantly
3. Analyze faster — Use Bayesian methods for quicker decisions
4. Synthesize learnings — Understand WHY something works, not just IF

What Changes​

Building Your AI Testing System​

Step 1: The Test Design Agent​

First, decide what to test. AI helps prioritize:

codex "Create a test prioritization function that:

Given current campaign performance metrics:
- Open rate: {{open_rate}}
- Reply rate: {{reply_rate}}
- Meeting rate: {{meeting_rate}}

And historical test results:
{{past_tests}}

Recommend the next 3 tests to run, ranked by:
1. Expected impact (how much could it move the needle?)
2. Confidence (do we have enough volume?)
3. Learning value (will results inform other campaigns?)

For each test, specify:
- Variable to test
- Hypothesis (why we think it might work)
- Sample size needed
- Success metric
- Timeline estimate"

Step 2: The Variant Generator​

Once you know what to test, generate variants:

// For subject line testing
const variantPrompt = `Generate 5 subject line variants for this email:

Current subject: "Quick question about {{company}}'s pipeline"
Current open rate: 28%

Target audience: VP Sales at 50-200 person SaaS companies
Email purpose: First outreach, cold lead

Generate variants across these dimensions:
1. Direct vs. curious
2. Short (4 words) vs. medium (7 words)  
3. Personalized vs. generic
4. Question vs. statement
5. Urgency vs. value-first

For each variant, explain the psychological principle it uses.
Rate predicted open rate improvement (-20% to +50%).`;

Example output:

Step 3: Bayesian Analysis Engine​

Traditional p-value testing is slow. Bayesian methods let you decide faster:

codex "Create a Bayesian A/B test analyzer that:

1. Takes conversion data for control and variants
2. Calculates probability each variant beats control
3. Recommends action:
   - 'Keep testing' if no variant >85% likely to win
   - 'Pick winner' if one variant >95% likely to beat all
   - 'Stop test, no winner' if all variants within 2% of each other

4. Estimates required additional sample for confident decision
5. Projects final expected lift with confidence interval

Use Beta-Binomial model for conversion metrics.
Output results in plain English + data table."

Sample output:

Test: Subject Line Experiment #14
Duration: 5 days
Sends: Control (847), V1 (852), V2 (844), V3 (851)

Results:
- Control: 31.2% open rate (264 opens)
- Variant 1: 38.4% open rate (327 opens) — 94% likely to beat control
- Variant 2: 29.8% open rate (251 opens) — 23% likely to beat control
- Variant 3: 33.6% open rate (286 opens) — 71% likely to beat control

Recommendation: Continue testing V1 for 2 more days. 
At current trajectory, 97% confidence expected by Thursday.

Expected lift if V1 wins: +18-26% open rate improvement
Annual impact estimate: +340 additional replies, ~68 extra meetings

Step 4: The Learning Synthesizer​

Don't just know WHAT won—understand WHY:

const synthesisPrompt = `Analyze these A/B test results and extract learnings:

Test: {{test_name}}
Date: {{date_range}}
Audience: {{audience}}

Results:
{{results_table}}

What patterns explain the winner?
- Message characteristics (length, tone, structure)
- Personalization elements
- Psychological triggers
- Timing factors

How should these learnings apply to:
1. Other email campaigns
2. LinkedIn outreach
3. Cold call scripts
4. Landing page copy

Add to our learning database in structured format.`;

Step 5: The Continuous Optimization Loop​

Tie it together with OpenClaw:

# Weekly optimization cycle
schedule:
  - name: "Monday Test Planning"
    cron: "0 9 * * 1"
    task: |
      1. Review last week's test results
      2. Archive completed tests to learning DB
      3. Generate new test recommendations
      4. Create variants for approved tests
      5. Configure test in email platform
      6. Post summary to Slack

  - name: "Daily Test Check"
    cron: "0 17 * * 1-5"
    task: |
      1. Pull latest metrics from active tests
      2. Run Bayesian analysis
      3. Flag any tests ready for decision
      4. Alert team if early winner emerging
      
  - name: "Friday Results Review"
    cron: "0 14 * * 5"
    task: |
      1. Compile weekly test report
      2. Update learning database
      3. Calculate cumulative improvement
      4. Recommend weekend automation changes

Real-World Testing Framework​

Email Sequence Testing​

Cold Call Script Testing​

LinkedIn Outreach Testing​

Case Study: 10 Tests in 10 Weeks​

Here's what a real AI-powered testing program delivered:

Starting Point​

• Email open rate: 28%
• Reply rate: 3.2%
• Meeting rate: 0.8%

Tests Run​

*Bayesian analysis found optimal point between tested options

Ending Point​

• Email open rate: 41% (+46%)
• Reply rate: 6.1% (+91%)
• Meeting rate: 1.8% (+125%)

Same volume, more than double the meetings.

Common Mistakes to Avoid​

Testing Too Many Things​

You don't need to test everything. Focus on:

• Variables with high potential impact
• Variables you can actually change
• Variables where you have a hypothesis

Skip testing whether "Regards" beats "Best"—it doesn't matter.

Ignoring Segmentation​

An email that wins for VP Sales might lose for SDR Managers. Always check if results hold across segments.

// Always segment analysis
const segments = ['VP+', 'Director', 'Manager', 'IC'];
segments.forEach(seg => {
  const segResults = analyzeBySegment(testData, seg);
  if (segResults.winner !== overallWinner) {
    alert(`Segment ${seg} prefers different variant!`);
  }
});

Declaring Winners Too Early​

Bayesian analysis is faster, but not instant. Still need sufficient data:

• Minimum 100 conversions per variant for reliable signals
• Watch for day-of-week effects (full week minimum)
• Check that winner is consistent, not a fluke

Not Documenting Learnings​

The test result isn't the value—the learning is. Document:

• What we tested
• What we hypothesized
• What actually happened
• Why we think it happened
• How this applies elsewhere

Building the Learning Database​

Create institutional memory that compounds:

// learning_db.schema
{
  test_id: 'test_2026_02_14',
  date: '2026-02-14',
  category: 'email_subject',
  hypothesis: 'Specific numbers increase open rates',
  variants: [...],
  winner: 'variant_a',
  lift: 0.18,
  confidence: 0.97,
  segment_notes: 'Held across all segments',
  explanation: 'Specificity creates curiosity. "3 ideas" beats "a few ideas"',
  applications: [
    'Use specific numbers in all email subjects',
    'Test numbered lists in LinkedIn headlines',
    'Apply to call opening hooks'
  ],
  related_tests: ['test_2025_11_02', 'test_2026_01_08']
}

Over time, this becomes your competitive advantage—a proprietary knowledge base of what works for YOUR audience.

Connecting to MarketBetter​

A/B testing is most powerful when integrated into your daily SDR workflow. MarketBetter's Daily SDR Playbook can:

• Apply winning templates — Automatically use your best-performing copy
• Segment for testing — Route prospects to test vs. control groups
• Track results — Measure conversions through to meeting and revenue
• Alert on changes — Notice when a winning approach stops working

Ready to see continuous optimization in action? Book a demo and we'll show you how AI-powered SDR workflows adapt in real-time.

Getting Started​

This Week​

1. Audit current campaigns—what are your baseline metrics?
2. Identify your biggest opportunity (open rate? reply rate? meetings?)
3. Design first test with 3-5 variants

This Month​

1. Run 2-3 tests
2. Set up Bayesian analysis script
3. Create learning database
4. Document first insights

This Quarter​

1. Average 2+ tests per week
2. Train team on reading test results
3. Build segment-specific playbooks
4. Measure cumulative improvement

The teams that test fastest, win.

Further Reading​

• AI Email Personalization at Scale — Generate test variants automatically
• 10 Codex Prompts That 10x SDR Productivity — Prompts for variant generation
• Build a 24/7 Pipeline Monitor with OpenClaw — Track test results in real-time

Stop guessing. Start testing. The data will show you what works.

Your SDRs are working accounts that will never close.

Not because they're lazy — because they can't tell which accounts matter. They're flying blind, treating a 10-person agency the same as a 500-person enterprise actively searching for your solution.

The result? According to TOPO research, SDRs spend 64% of their time on accounts that will never buy.

AI changes this equation completely.

The Account Prioritization Problem​

Traditional lead scoring is broken:

What most companies do:

• Assign points for form fills and page views
• Use static firmographic filters (size, industry)
• Update scores manually (if at all)
• Let SDRs pick accounts based on gut feel

What actually matters:

• Is the company actively researching solutions?
• Did they just get funding (budget unlocked)?
• Is the decision-maker engaging with your content?
• Do they match your best customer profile — really?
• What are they saying about you to competitors?

Static scoring can't capture this. AI can.

The AI Account Scoring Model​

Here's how to build an account prioritization engine that actually works:

Layer 1: Firmographic Fit​

Basic but essential. Use AI to enrich and score:

Signals:

• Company size (employees, revenue)
• Industry vertical
• Tech stack (from BuiltWith, Wappalyzer)
• Geography
• Growth indicators (hiring, office expansion)

AI Enhancement: Instead of binary yes/no on ICP fit, Claude analyzes:

Company: TechCorp Industries
Employees: 200
Industry: Manufacturing IoT

Analysis:
- Primary ICP match (IoT vertical)
- Size is mid-market (secondary target)
- Tech stack includes Salesforce (integration opportunity)
- Recently hired 3 sales roles (scaling GTM)

Firmographic Score: 78/100
Reasoning: Strong vertical fit, actively investing in sales, but not enterprise-tier deal size.

Layer 2: Intent Signals​

This is where AI shines. Track and score:

First-party intent:

• Website visits (pages, frequency, recency)
• Content downloads
• Pricing page views
• Demo page visits without booking
• Email engagement patterns

Third-party intent:

• G2 category searches
• Competitor comparison searches
• Review site activity
• Industry publication engagement
• Job posting analysis

AI Processing:

const intentSignals = {
  websiteVisits: [
    { page: "/pricing", visits: 3, lastVisit: "2 days ago" },
    { page: "/vs-competitor", visits: 2, lastVisit: "1 day ago" },
    { page: "/case-studies", visits: 5, lastVisit: "today" }
  ],
  thirdPartyIntent: {
    g2Searches: ["SDR tools", "sales automation"],
    competitorResearch: ["Apollo", "Outreach"]
  }
};

// Claude's analysis
const intentScore = await claude.analyze({
  signals: intentSignals,
  prompt: `
    Analyze these intent signals for purchase readiness.
    Score 1-100 and explain the buying stage.
    
    Key indicators:
    - Pricing page visits = late-stage research
    - Competitor comparison = active evaluation
    - Multiple stakeholders visiting = committee forming
  `
});

// Output: Score 85/100
// "Active evaluation stage. Multiple pricing page visits 
//  combined with competitor research indicates they're 
//  building a shortlist. Recommend immediate outreach 
//  with differentiation messaging against Apollo/Outreach."

Layer 3: Engagement Recency​

Recent activity trumps historical engagement. Use AI to weight:

Decay model:

• Activity today = 100% value
• Activity this week = 80% value
• Activity this month = 50% value
• Activity > 30 days = 20% value

AI Enhancement: Claude considers context:

Engagement Pattern Analysis:

Account: DataFlow Inc.

- Downloaded pricing guide: 45 days ago
- Visited website: 2 days ago (pricing page)
- Downloaded competitor comparison: 1 day ago
- VP Sales viewed LinkedIn post: Today

Assessment: REACTIVATED INTEREST
Despite aging initial engagement, there's clear evidence 
of resumed evaluation. Recent pricing + comparison 
activity suggests they're revisiting a delayed decision.

Recommended action: Re-engage with "what's changed" 
messaging, reference their earlier interest.

Layer 4: Relationship Signals​

Who you know matters:

Signals:

• Previous interactions (calls, emails)
• Connection to existing customers
• Shared investors or advisors
• Conference attendance overlap
• Mutual LinkedIn connections

AI Processing:

Relationship Mapping:

Account: CloudScale Systems

- CRO previously worked at [Current Customer]
- Two LinkedIn connections in common with your team
- Attended same industry conference last quarter
- No previous outreach from your company

Relationship Score: 45/100
Opportunity: Warm intro possible through [Customer] 
connection. Mention shared conference for relevance.

Layer 5: Propensity Modeling​

This is the AI secret weapon — predicting which accounts will buy:

Training data:

• Historical won deals (what did they look like before close?)
• Lost deals (what warning signs appeared?)
• Time-to-close patterns
• Champion personas
• Common objections by segment

AI Model:

# Simplified propensity scoring
propensity_factors = {
    "matches_closed_won_profile": 0.35,
    "intent_signal_strength": 0.25,
    "engagement_recency": 0.20,
    "relationship_warmth": 0.10,
    "firmographic_fit": 0.10
}

# Claude augments with reasoning
propensity_prompt = """
Based on our historical data:
- Accounts that close have 3+ website visits in final month
- Champions are typically VP+ level
- Deals with competitor mentions close 40% faster
- Manufacturing IoT has 2x close rate vs general SaaS

Analyze this account against these patterns and predict 
close probability with confidence interval.
"""

Building the Automation with OpenClaw​

Here's how to run this 24/7:

OpenClaw Agent Configuration​

# account-prioritization-agent.yaml
name: Account Prioritizer
schedule: "0 6 * * *"  # Run daily at 6 AM

data_sources:
  - hubspot_accounts
  - website_analytics
  - g2_intent_data
  - linkedin_sales_navigator

workflow:
  1_enrich:
    action: enrich_accounts
    sources: [clearbit, apollo, builtwith]
    
  2_score:
    action: ai_score
    model: claude-3-5-sonnet
    scoring_layers:
      - firmographic_fit
      - intent_signals
      - engagement_recency
      - relationship_mapping
      - propensity_model
    
  3_prioritize:
    action: rank_accounts
    tiers:
      hot: score >= 80
      warm: score >= 60
      nurture: score >= 40
      archive: score < 40
    
  4_route:
    action: assign_to_reps
    rules:
      - hot: round_robin_senior_reps
      - warm: round_robin_all_reps
      - nurture: marketing_automation
    
  5_notify:
    action: slack_alert
    channel: "#sales-prioritization"
    message: "Daily account prioritization complete. {hot_count} hot, {warm_count} warm."

Daily Output Example​

🎯 DAILY ACCOUNT PRIORITIZATION - Feb 9, 2026

HOT (Immediate outreach) - 12 accounts
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. DataFlow Inc. | Score: 94
   └─ Why: 5 pricing views, downloaded ROI calc, VP on LinkedIn
   └─ Action: Sarah to call - warm intro available through CloudCo
   
2. TechCorp Industries | Score: 91
   └─ Why: Competitor comparison research, 3 stakeholders visiting
   └─ Action: Mike to email - use manufacturing IoT case study
   
3. ScaleUp Systems | Score: 87
   └─ Why: Series B last week, hiring 4 SDRs, founder liked our post
   └─ Action: Sarah to DM founder on LinkedIn

WARM (This week) - 28 accounts
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

4. Velocity Labs | Score: 72
   └─ Why: Downloaded comparison guide, ICP fit, no recent activity
   └─ Action: Nurture sequence #2
   
[...]

CHANGES FROM YESTERDAY:
- DataFlow Inc.: ↑ 45 → 94 (pricing page spike)
- OldCorp LLC: ↓ 65 → 38 (went dark, moving to nurture)
- NewTech Co.: NEW at 71 (first-time visitor, strong fit)

Measuring Impact​

Track these metrics before and after implementing AI prioritization:

The math:

• SDR costs: $75K/year fully loaded
• Time recovered from bad accounts: ~25 hours/week
• Value of recovered time: ~$45K/year
• If that time books 2 extra meetings/week at $5K deal value = $520K pipeline

ROI is obvious.

Common Mistakes to Avoid​

Mistake 1: Over-weighting firmographics​

Big company ≠ good prospect. A 10,000-person enterprise with no intent signals is worse than a 100-person startup actively searching.

Fix: Weight intent and engagement higher than firmographics.

Mistake 2: Ignoring negative signals​

Some accounts should be deprioritized:

• Recently churned
• In active legal dispute
• Competitor's biggest customer
• Bad reviews about your company

Fix: Include disqualification criteria in your scoring model.

Mistake 3: Static scoring​

Markets change. Your ideal customer evolves. Scoring models decay.

Fix: Re-train your propensity model quarterly using recent closed-won/lost data.

Mistake 4: Not explaining the score​

SDRs won't trust black-box scores.

Fix: Always show WHY an account scored high/low. Claude excels at this reasoning.

Getting Started​

Week 1: Foundation​

• Export your CRM data (last 12 months of closed deals)
• Identify your 5-layer scoring criteria
• Set up intent data sources (G2, Bombora, or website tracking)

Week 2: Build​

• Create your Claude scoring prompts
• Configure OpenClaw agent
• Run first batch scoring on test accounts

Week 3: Validate​

• Compare AI scores against rep intuition
• Adjust weightings based on feedback
• Review edge cases (high-score no-shows, low-score wins)

Week 4: Deploy​

• Route scores to CRM
• Set up daily Slack reports
• Train reps on using prioritization data

Ready to Prioritize Smarter?​

AI account prioritization isn't the future — your competitors are using it now.

Every day you waste time on bad-fit accounts is a day your competitors are closing the good ones.

Next steps:

1. Audit your current scoring model (or lack thereof)
2. Identify your intent data gaps
3. Book a demo with MarketBetter to see AI prioritization in action

Because working harder is not the same as working smarter.

Customer churn is the silent killer of SaaS businesses. By the time a customer formally announces they're leaving, the decision was made weeks or months earlier.

What if you could predict churn before it happens—and intervene while there's still time?

This guide shows you how to build an AI-powered churn prediction system using Claude Code that monitors customer health signals, identifies at-risk accounts, and triggers proactive outreach before customers walk out the door.

Why Traditional Churn Indicators Fail​

Most companies rely on lagging indicators for churn:

• NPS surveys — Customers who've already decided to leave give low scores
• Support ticket volume — By the time tickets spike, frustration is entrenched
• Usage metrics — Monthly logins don't capture engagement quality
• Renewal conversations — Too late to change minds

The problem? These signals arrive after the damage is done. You're reacting to churn, not preventing it.

The Leading Indicator Advantage​

AI-powered churn prediction flips the script by analyzing leading indicators:

Claude Code's 200K context window lets you analyze months of customer behavior patterns simultaneously—something impossible with simpler tools.

The Churn Prediction Architecture​

Here's what we're building:

1. Data Collection Layer — Pull signals from CRM, product analytics, and support
2. Claude Code Analysis — Process patterns and assign risk scores
3. Alert System — Notify CSMs about at-risk accounts with context
4. Action Triggers — Auto-queue intervention workflows

Let's build each component.

Step 1: Define Your Churn Signals​

Before writing code, identify the signals that predict churn in your business. Here's a framework:

Product Engagement Signals​

- Login frequency (trending down?)
- Feature adoption breadth (using fewer features?)
- Key feature usage (stopped using sticky features?)
- Time-in-app (shorter sessions?)
- Power user count (champions leaving?)

Relationship Signals​

- Executive sponsor changes
- Champion job changes (LinkedIn monitoring)
- Support ticket sentiment (increasingly negative?)
- Response time to your emails (slower?)
- Meeting no-shows (increasing?)

Business Signals​

- Company funding/layoffs news
- Competitive mentions in calls
- Pricing discussions initiated
- Contract terms questions
- "Evaluation" language in emails

Implementation Priority​

Score each signal by predictive power and data availability:

Step 2: Build the Data Aggregation Layer​

Create a script that pulls customer health data from your systems:

// customer-health-collector.js
const healthSignals = {
  async collectForAccount(accountId) {
    const [crm, product, support, linkedin] = await Promise.all([
      this.getCRMData(accountId),
      this.getProductMetrics(accountId),
      this.getSupportHistory(accountId),
      this.getChampionStatus(accountId)
    ]);

    return {
      accountId,
      collectedAt: new Date().toISOString(),
      signals: {
        engagement: product,
        relationship: crm,
        support: support,
        champions: linkedin
      }
    };
  },

  async getProductMetrics(accountId) {
    // Return: logins, feature usage, API calls, active users
    // Compare current period vs previous period
    return {
      loginTrend: -15, // % change
      featureAdoption: 72, // % of features used
      powerUsers: 3, // count
      apiVolume: 45000 // calls this month
    };
  }
};

The key insight: Claude needs trending data, not point-in-time snapshots. A customer with 50 logins this month isn't at risk—unless they had 100 logins last month.

Step 3: The Claude Code Churn Analysis Prompt​

Here's where the magic happens. This prompt turns raw signals into actionable risk assessments:

You are analyzing customer health data to predict churn risk.

ACCOUNT DATA:
{customerHealthData}

HISTORICAL PATTERNS (from churned accounts):
- 73% of churned accounts showed >20% login decline in final 60 days
- 81% had champion job changes within 90 days of churn
- 68% reduced feature adoption by >30% before canceling
- Average time from first warning signal to churn: 47 days

ANALYSIS FRAMEWORK:

1. RISK SCORE (0-100):
   - 0-25: Healthy
   - 26-50: Monitor
   - 51-75: At Risk
   - 76-100: Critical

2. For each signal, assess:
   - Current value vs baseline
   - Trend direction and velocity
   - Correlation with historical churn patterns

3. OUTPUT FORMAT:
{
  "riskScore": number,
  "riskLevel": "healthy|monitor|at-risk|critical",
  "primaryRiskFactors": [
    {
      "signal": "string",
      "severity": "low|medium|high|critical",
      "evidence": "string",
      "suggestedAction": "string"
    }
  ],
  "recommendedInterventions": [
    {
      "action": "string",
      "urgency": "immediate|this-week|this-month",
      "owner": "CSM|Executive|Support",
      "talking_points": ["string"]
    }
  ],
  "healthSummary": "2-3 sentence executive summary"
}

Step 4: Build the Analysis Pipeline​

Connect your data collection to Claude Code analysis:

// churn-analyzer.js
const Anthropic = require("@anthropic-ai/sdk");

const analyzeChurnRisk = async (accountId) => {
  const healthData = await healthSignals.collectForAccount(accountId);
  
  const client = new Anthropic();
  const response = await client.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 2000,
    messages: [
      {
        role: "user",
        content: CHURN_ANALYSIS_PROMPT.replace(
          "{customerHealthData}",
          JSON.stringify(healthData, null, 2)
        )
      }
    ]
  });

  const analysis = JSON.parse(response.content[0].text);
  
  // Store analysis for trending
  await db.saveChurnAnalysis(accountId, analysis);
  
  // Trigger alerts if needed
  if (analysis.riskScore > 50) {
    await alertCSM(accountId, analysis);
  }
  
  return analysis;
};

Step 5: Set Up Alert Workflows​

When Claude identifies an at-risk account, trigger immediate action:

// alert-workflows.js
const alertCSM = async (accountId, analysis) => {
  const account = await crm.getAccount(accountId);
  const csm = await crm.getAccountOwner(accountId);
  
  // Slack alert to CSM
  await slack.send(csm.slackId, {
    text: `⚠️ Churn Risk Alert: ${account.name}`,
    blocks: [
      {
        type: "section",
        text: {
          type: "mrkdwn",
          text: `*${account.name}* risk score increased to *${analysis.riskScore}/100*`
        }
      },
      {
        type: "section",
        text: {
          type: "mrkdwn",
          text: `*Top Risk Factors:*\n${analysis.primaryRiskFactors
            .map(f => `• ${f.signal}: ${f.evidence}`)
            .join('\n')}`
        }
      },
      {
        type: "section",
        text: {
          type: "mrkdwn",
          text: `*Recommended Action:*\n${analysis.recommendedInterventions[0].action}`
        }
      }
    ]
  });

  // Create task in CRM
  await crm.createTask({
    accountId,
    ownerId: csm.id,
    subject: `Churn Risk: ${account.name} (Score: ${analysis.riskScore})`,
    description: analysis.healthSummary,
    dueDate: analysis.recommendedInterventions[0].urgency === 'immediate' 
      ? 'today' 
      : 'this_week',
    priority: analysis.riskScore > 75 ? 'high' : 'medium'
  });
};

Step 6: Automate Daily Monitoring​

Run churn analysis across your entire book of business:

// daily-churn-scan.js
const scanAllAccounts = async () => {
  const accounts = await crm.getActiveAccounts();
  const results = [];

  for (const account of accounts) {
    const analysis = await analyzeChurnRisk(account.id);
    results.push({ account: account.name, ...analysis });
  }

  // Generate executive summary
  const atRisk = results.filter(r => r.riskScore > 50);
  const critical = results.filter(r => r.riskScore > 75);

  await slack.send('#customer-success', {
    text: `📊 Daily Churn Report`,
    blocks: [
      {
        type: "section",
        text: {
          type: "mrkdwn",
          text: `*Daily Customer Health Summary*\n` +
            `• Total accounts analyzed: ${results.length}\n` +
            `• At-risk accounts: ${atRisk.length}\n` +
            `• Critical accounts: ${critical.length}`
        }
      },
      critical.length > 0 && {
        type: "section",
        text: {
          type: "mrkdwn",
          text: `*🚨 Critical Accounts:*\n${critical
            .map(c => `• ${c.account} (${c.riskScore}/100)`)
            .join('\n')}`
        }
      }
    ].filter(Boolean)
  });

  return results;
};

The ROI of AI Churn Prediction​

Let's do the math:

Before AI churn prediction:

• 100 accounts, 8% annual churn = 8 lost customers
• Average ACV: $50,000
• Annual churn cost: $400,000

After AI churn prediction:

• Same 100 accounts
• Predict 80% of churn (historical accuracy)
• Save 50% of predicted churns through intervention
• New churn: 8 - (8 × 0.8 × 0.5) = 4.8 customers
• Churn cost: $240,000
• Annual savings: $160,000

And that's conservative. Top companies using AI churn prediction report 30-50% reductions in churn rate.

Advanced: Champion Monitoring with LinkedIn​

The single best predictor of churn? Your champion leaving the company.

Here's how to automate champion monitoring:

// champion-monitor.js
const monitorChampions = async () => {
  const champions = await crm.getChampions(); // Contacts tagged as champions
  
  for (const champion of champions) {
    const linkedinProfile = await linkedin.getProfile(champion.linkedinUrl);
    const currentCompany = linkedinProfile.experience[0]?.company;
    
    if (currentCompany !== champion.account.name) {
      // Champion has left!
      await alertChampionChange({
        champion,
        previousCompany: champion.account.name,
        newCompany: currentCompany,
        analysis: await analyzeImpact(champion)
      });
    }
  }
};

When a champion leaves, Claude can analyze the impact:

• Was this the executive sponsor?
• Who else do we know at the account?
• What's the typical churn timeline after champion departure?
• What intervention has worked historically?

Connecting to MarketBetter​

MarketBetter's daily SDR playbook applies the same predictive intelligence to pipeline—telling your team exactly who to contact and what to say.

For customer success teams, the playbook surfaces:

• At-risk accounts requiring immediate attention
• Expansion opportunities based on usage patterns
• Optimal timing for QBRs and check-ins
• Talking points based on recent product usage

The difference between reactive and proactive customer success is the difference between fighting churn and preventing it.

See how MarketBetter's AI-powered playbook works →

Implementation Checklist​

Ready to build your own churn prediction system?

• Map your churn signals (product, relationship, business)
• Set up data collection from CRM + product analytics
• Create Claude Code analysis prompts with your historical patterns
• Build alert workflows to CSM team
• Test on known churned accounts to calibrate
• Deploy daily automated scanning
• Add champion monitoring
• Track intervention success rates

The best time to prevent churn was 60 days before the customer decided to leave. The second best time is now—with AI-powered prediction that catches the warning signs you'd otherwise miss.

Building AI agents for GTM? Check out our guides on customer success automation with OpenClaw and training custom AI agents for your sales process.

The uncomfortable truth: Most B2B companies don't know a customer is churning until they've already decided to leave.

By the time the renewal conversation happens, it's too late. The competitor calls have been made. The internal evaluation is done. You're not renewing—you're negotiating their exit.

But what if you could see churn coming 90 days out? What if you could identify expansion opportunities before the customer even asks?

This isn't fantasy. AI agents running 24/7 can monitor every signal, predict every risk, and trigger every action—automatically.

Why Contract Renewals Fail​

Let's be honest about why renewal rates suffer:

1. You're reactive, not proactive Customer Success teams are buried in firefighting. By the time you check who's renewing next month, the at-risk accounts have already made decisions.

2. Signals are scattered Usage data is in one system. Support tickets in another. NPS scores somewhere else. No human can synthesize it all.

3. Outreach is generic "Hey, your renewal is coming up!" isn't a strategy. It's a reminder—and a weak one.

4. Expansion is an afterthought You're so focused on not losing revenue that you forget to grow it.

AI solves all four problems. Here's how.

The AI-Powered Renewal Workflow​

A properly configured AI renewal system does five things:

1. Monitors health signals continuously
2. Predicts churn risk before it's obvious
3. Generates personalized outreach at scale
4. Identifies expansion triggers automatically
5. Keeps humans focused on high-value conversations

Let's build each piece.

Step 1: Continuous Health Monitoring with OpenClaw​

OpenClaw agents can monitor your customer base 24/7, synthesizing signals you'd never catch manually.

# Health monitoring agent configuration
schedule:
  kind: cron
  expr: "0 6 * * *"  # Daily at 6am

payload:
  kind: agentTurn
  message: |
    Review all customers renewing in the next 90 days.
    For each, check:
    - Product usage trends (up, flat, declining?)
    - Support ticket volume and sentiment
    - Last CSM touchpoint
    - NPS/CSAT scores
    - Champion status (still at company?)
    
    Flag any account with 2+ warning signals.
    Create tasks for CSM outreach on flagged accounts.

The agent runs daily, cross-references data sources, and only escalates accounts that need attention.

What this catches:

• Usage dropped 40% last month (they're evaluating alternatives)
• 5 support tickets in 2 weeks (they're frustrated)
• Main champion left the company (your internal advocate is gone)
• NPS score dropped from 9 to 6 (something changed)

Step 2: Churn Risk Prediction with Claude Code​

Claude Code excels at analyzing complex patterns across data sources. Here's how to build a risk scoring system:

# Renewal risk analyzer with Claude Code
def analyze_renewal_risk(customer_data):
    """
    Analyzes multiple signals to predict churn probability
    """
    risk_factors = []
    
    # Usage decline detection
    if customer_data['usage_trend'] < -0.20:  # 20%+ decline
        risk_factors.append({
            'signal': 'usage_decline',
            'severity': 'high',
            'detail': f"Usage down {abs(customer_data['usage_trend']):.0%} vs last quarter"
        })
    
    # Support sentiment analysis
    if customer_data['support_sentiment'] < 0.6:  # Below threshold
        risk_factors.append({
            'signal': 'support_frustration',
            'severity': 'medium',
            'detail': f"Negative sentiment in {customer_data['negative_tickets']} recent tickets"
        })
    
    # Champion tracking
    if customer_data['champion_status'] == 'departed':
        risk_factors.append({
            'signal': 'champion_loss',
            'severity': 'critical',
            'detail': f"Primary champion {customer_data['champion_name']} left on {customer_data['departure_date']}"
        })
    
    # Calculate composite score
    severity_weights = {'low': 1, 'medium': 2, 'high': 3, 'critical': 5}
    risk_score = sum(severity_weights[f['severity']] for f in risk_factors)
    
    return {
        'customer': customer_data['name'],
        'risk_score': risk_score,
        'risk_level': 'critical' if risk_score >= 5 else 'high' if risk_score >= 3 else 'medium',
        'factors': risk_factors,
        'recommended_actions': generate_action_plan(risk_factors)
    }

Claude's 200K context window means it can analyze an entire customer's history—every ticket, every call note, every usage pattern—in a single pass.

Step 3: Personalized Outreach with Codex​

Generic renewal emails get ignored. AI-generated, context-rich outreach gets responses.

Here's how Codex GPT-5.3 generates renewal touchpoints:

// Renewal outreach generator using Codex
async function generateRenewalOutreach(customer, riskLevel) {
  const context = await gatherCustomerContext(customer.id);
  
  const prompt = `
    Generate a personalized renewal touchpoint for:
    
    Customer: ${customer.name}
    Risk Level: ${riskLevel}
    Renewal Date: ${customer.renewal_date}
    
    Context:
    - Primary use case: ${context.primary_use_case}
    - Key wins: ${context.documented_wins.join(', ')}
    - Recent challenges: ${context.recent_issues.join(', ')}
    - Champion: ${context.champion.name} (${context.champion.title})
    
    Generate:
    1. Email subject line (personalized, not salesy)
    2. Email body (reference specific wins, acknowledge any issues, propose value review)
    3. Suggested follow-up sequence if no response
    
    Tone: Consultative, not pushy. We're their partner, not their vendor.
  `;
  
  const outreach = await codex.generate(prompt);
  return outreach;
}

Example output:

Subject: Quick thought on your Q2 expansion plans

Hi Sarah,

I was reviewing the 47% increase in qualified leads your team drove through MarketBetter last quarter—impressive execution on the ABM campaigns.

With your renewal coming up in March, I wanted to share some ideas we've seen work well for teams scaling from 5 to 10 SDRs. Specifically around territory mapping and the new intent signals we released.

Would a 20-minute call next week work to explore what Q2 could look like?

No "your renewal is coming up." No generic value props. Just relevant context that shows you're paying attention.

Step 4: Expansion Opportunity Detection​

Here's where AI really shines—finding revenue you didn't know was there.

OpenClaw agents can monitor for expansion triggers:

# Expansion trigger detection
schedule:
  kind: cron
  expr: "0 9 * * MON"  # Weekly on Monday

payload:
  kind: agentTurn
  message: |
    Scan customer base for expansion signals:
    
    1. USAGE EXPANSION
       - Accounts approaching plan limits
       - Features at >80% utilization
       - New user invites (team growing)
    
    2. ORG EXPANSION
       - New departments using product
       - International office mentions
       - Subsidiary/acquired company news
    
    3. BUDGET SIGNALS
       - Job postings indicating team growth
       - Funding announcements
       - Fiscal year timing (Q1 budget releases)
    
    For each signal:
    - Rate expansion probability (1-10)
    - Estimate potential ARR impact
    - Draft outreach angle
    - Assign to appropriate CSM/AE

Signals that indicate expansion:

Step 5: Keeping Humans in the Loop​

AI doesn't replace your CS team—it makes them superhuman.

The workflow:

1. AI monitors everything continuously
2. AI flags accounts that need attention
3. AI drafts outreach and recommendations
4. Humans review and personalize
5. Humans have high-value conversations
6. AI follows up on action items

# Human-in-the-loop workflow
when: ai_flags_risk_account

do:
  - create_task:
      assignee: csm
      title: "Review renewal risk: {customer_name}"
      body: |
        AI Analysis:
        {risk_summary}
        
        Recommended Actions:
        {action_plan}
        
        Draft Outreach:
        {generated_email}
        
        Please review and adjust before sending.
      due: 2_business_days

Real Results: What This Looks Like​

Companies running AI-powered renewal systems see:

• 30-day earlier churn risk detection
• 15%+ improvement in gross retention
• 25%+ improvement in net revenue retention
• 60% reduction in CSM time spent on data gathering

The math is simple: If your CSM can spend 80% of their time on strategic conversations instead of Salesforce data entry, they'll save more accounts.

Building Your System: Claude Code vs Codex vs OpenClaw​

Each tool has its strength:

Pro tip: Use OpenClaw as the orchestration layer that coordinates Claude and Codex for specific tasks.

Implementation Checklist​

Ready to automate your renewal process? Here's your roadmap:

Week 1: Data Foundation

• Inventory all customer health signals (usage, support, NPS, engagement)
• Ensure data is accessible via API or export
• Define your churn risk criteria

Week 2: Monitoring Setup

• Deploy OpenClaw renewal monitoring agent
• Configure daily/weekly health scans
• Set up alert thresholds

Week 3: Outreach Automation

• Build outreach templates for each risk tier
• Configure Codex/Claude for personalization
• Create approval workflow for AI-generated emails

Week 4: Expansion Detection

• Define expansion trigger signals
• Configure monitoring for each signal type
• Build routing to appropriate owner (CSM vs AE)

The Bottom Line​

Contract renewal isn't a 30-day process. It's a continuous relationship.

AI lets you treat it that way—monitoring every signal, catching every risk, and surfacing every opportunity—without drowning your team in busywork.

The companies winning on retention aren't the ones with the biggest CS teams. They're the ones with the smartest systems.

Build yours now.

Ready to see how MarketBetter's AI-powered platform can help your team identify at-risk accounts and expansion opportunities automatically?

Book a Demo →

Your sales team runs hundreds of discovery calls per year. Each one is a goldmine of customer intelligence:

• Pain points and priorities
• Competitive insights
• Buying process details
• Objections and concerns
• Success metrics that matter

But most of it disappears. The rep remembers key points (maybe). Some notes make it to the CRM (inconsistently). The full context? Lost in a recording nobody will watch.

What if every call automatically fed a searchable database of buyer intelligence? What if you could ask "What do healthcare buyers care about most?" and get an instant answer from 50+ relevant calls?

Claude Code makes this possible.

The Problem: Trapped Intelligence​

Here's what typically happens with discovery calls:

1. Rep takes call — Has great conversation, uncovers real insights
2. Rep updates CRM — Writes 2-3 bullet points in the notes field
3. Recording sits unused — Maybe reviewed for coaching, usually not
4. Insights forgotten — Within a week, details are gone
5. Repeat for next call — Same questions, same lost insights

The result? Every new deal starts from scratch. Product teams don't hear customer language. Marketing creates content based on assumptions. Sales enablement builds training without real examples.

What AI Interview Analysis Delivers​

With Claude's 200K context window, you can:

1. Extract Structured Insights​

Turn unstructured conversations into structured data:

{
  "company": "Acme Corp",
  "call_date": "2026-02-09",
  "participants": ["John Smith (VP Sales)", "Lisa Chen (SDR Manager)"],
  "pain_points": [
    {
      "pain": "SDRs spend 4+ hours daily on research before calling",
      "severity": "high",
      "quote": "My reps are researchers who sometimes make calls"
    },
    {
      "pain": "No visibility into which leads are actually engaged",
      "severity": "medium",
      "quote": "We're flying blind on who's hot and who's not"
    }
  ],
  "current_solution": "Salesforce + SalesLoft + ZoomInfo",
  "switching_triggers": ["ZoomInfo contract up in Q2", "New VP wants consolidation"],
  "competitors_mentioned": ["Apollo", "Outreach"],
  "budget_signals": "Has budget, looking to consolidate not add",
  "decision_process": "VP decides, finance approves over $30K",
  "timeline": "Want to decide by end of March",
  "success_metrics": ["Pipeline per rep", "Speed to first meeting"],
  "objections": ["Worried about data quality", "Change management concern"],
  "next_steps": "Demo with full team next Wednesday"
}

2. Build a Searchable Knowledge Base​

Query your call database:

• "What objections do companies mention about our pricing?"
• "How do healthcare buyers describe their pain points?"
• "What competitors come up most often in deals over $50K?"
• "What success metrics do CTOs care about?"

3. Surface Patterns Across Calls​

• 73% of prospects mention "too many tools" as a pain point
• "Apollo" mentioned in 34% of competitive deals
• Mid-market companies care about implementation time 2x more than enterprise
• Discovery calls with 3+ participants close at 67% vs 41%

4. Feed Product and Marketing​

• Real customer language for copy
• Feature requests with context
• Competitive intelligence aggregated
• Case study candidates identified

Building the Analysis System​

Step 1: Transcript Ingestion​

First, get transcripts from your conversation intelligence tool (Gong, Chorus, Fireflies, etc.):

# interview_analyzer.py
import os
from anthropic import Anthropic
from datetime import datetime

client = Anthropic()

def get_transcripts_from_gong(days: int = 7) -> list:
    """Pull recent call transcripts from Gong"""
    
    # Gong API call
    calls = gong_client.get_calls(
        from_date=datetime.now() - timedelta(days=days),
        call_type="discovery"
    )
    
    transcripts = []
    for call in calls:
        transcript = gong_client.get_transcript(call["id"])
        transcripts.append({
            "call_id": call["id"],
            "date": call["date"],
            "participants": call["participants"],
            "company": call["company_name"],
            "deal_id": call.get("deal_id"),
            "transcript": transcript
        })
    
    return transcripts

Step 2: AI Analysis​

Use Claude's massive context window to analyze full transcripts:

INTERVIEW_ANALYSIS_PROMPT = """
You are an expert sales analyst extracting structured intelligence from discovery calls.

Analyze the transcript and extract:

1. PAIN POINTS
   - What problems does the prospect describe?
   - How severe is each pain? (low/medium/high)
   - Include direct quotes that capture the pain

2. CURRENT STATE
   - What tools/processes do they use today?
   - What's working and what's not?
   - What triggered this evaluation?

3. BUYING PROCESS
   - Who's involved in the decision?
   - What's the timeline?
   - What's the budget situation?
   - What approval process exists?

4. COMPETITIVE LANDSCAPE
   - What competitors were mentioned?
   - What do they like/dislike about each?
   - Who are they also evaluating?

5. SUCCESS METRICS
   - How will they measure success?
   - What KPIs matter most?
   - What does "good" look like to them?

6. OBJECTIONS & CONCERNS
   - What hesitations came up?
   - What risks do they perceive?
   - What would prevent them from buying?

7. NEXT STEPS
   - What was agreed for follow-up?
   - Who else needs to be involved?
   - What timeline was discussed?

8. NOTABLE QUOTES
   - Capture 3-5 quotes that are especially insightful
   - These should be usable in marketing/sales materials

Output as JSON with clear structure.
"""

def analyze_interview(transcript_data: dict) -> dict:
    """Analyze a single interview transcript"""
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=3000,
        system=INTERVIEW_ANALYSIS_PROMPT,
        messages=[
            {"role": "user", "content": f"""
            Analyze this discovery call:
            
            Company: {transcript_data['company']}
            Date: {transcript_data['date']}
            Participants: {transcript_data['participants']}
            
            Transcript:
            {transcript_data['transcript']}
            """}
        ]
    )
    
    analysis = json.loads(response.content[0].text)
    
    # Add metadata
    analysis["call_id"] = transcript_data["call_id"]
    analysis["deal_id"] = transcript_data.get("deal_id")
    analysis["analyzed_at"] = datetime.now().isoformat()
    
    return analysis

Step 3: Knowledge Base Storage​

Store analyzed insights for querying:

def store_interview_analysis(analysis: dict):
    """Store analysis in searchable database"""
    
    # Store in Supabase (or your DB of choice)
    supabase.table("interview_analyses").insert({
        "call_id": analysis["call_id"],
        "company": analysis["company"],
        "call_date": analysis["date"],
        "pain_points": json.dumps(analysis["pain_points"]),
        "current_state": json.dumps(analysis["current_state"]),
        "buying_process": json.dumps(analysis["buying_process"]),
        "competitors": json.dumps(analysis["competitors"]),
        "success_metrics": json.dumps(analysis["success_metrics"]),
        "objections": json.dumps(analysis["objections"]),
        "notable_quotes": json.dumps(analysis["notable_quotes"]),
        "raw_analysis": json.dumps(analysis)
    }).execute()
    
    # Also store individual pain points for searching
    for pain in analysis["pain_points"]:
        supabase.table("pain_points").insert({
            "call_id": analysis["call_id"],
            "company": analysis["company"],
            "industry": analysis.get("industry"),
            "pain": pain["pain"],
            "severity": pain["severity"],
            "quote": pain.get("quote"),
            "call_date": analysis["date"]
        }).execute()
    
    # Store competitor mentions
    for competitor in analysis.get("competitors", []):
        supabase.table("competitor_mentions").insert({
            "call_id": analysis["call_id"],
            "competitor": competitor["name"],
            "sentiment": competitor.get("sentiment"),
            "context": competitor.get("context"),
            "call_date": analysis["date"]
        }).execute()

Step 4: Query Interface​

Now build ways to query the intelligence:

def query_interview_insights(question: str) -> str:
    """Answer questions using interview knowledge base"""
    
    # First, search for relevant interviews
    relevant_calls = search_interviews(question)
    
    # Build context from matches
    context = []
    for call in relevant_calls[:10]:  # Top 10 matches
        context.append({
            "company": call["company"],
            "date": call["call_date"],
            "insights": call["raw_analysis"]
        })
    
    # Ask Claude to answer using context
    prompt = f"""
    You have access to analyzed customer interview data. Use it to answer this question:
    
    Question: {question}
    
    Relevant interview data:
    {json.dumps(context, indent=2)}
    
    Provide a comprehensive answer with:
    1. Direct answer to the question
    2. Supporting evidence from calls (with quotes when relevant)
    3. Patterns you notice across multiple calls
    4. Confidence level based on data volume
    """
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1500,
        messages=[{"role": "user", "content": prompt}]
    )
    
    return response.content[0].text

# Example queries
print(query_interview_insights("What are the top 3 pain points for mid-market companies?"))
print(query_interview_insights("How do prospects describe their current tools' limitations?"))
print(query_interview_insights("What concerns do CFOs raise about switching tools?"))

Step 5: Pattern Analysis​

Surface trends automatically:

def generate_weekly_insights_report() -> str:
    """Generate weekly trends from interview analyses"""
    
    # Get last week's analyses
    recent_analyses = get_analyses(days=7)
    
    prompt = f"""
    Analyze these {len(recent_analyses)} discovery calls from the past week and identify:
    
    1. TOP PAIN POINTS
       - What pains came up most frequently?
       - Any new pains emerging?
       - Changes from previous weeks?
    
    2. COMPETITIVE LANDSCAPE
       - Which competitors mentioned most?
       - How are we positioned against each?
       - Any new competitors appearing?
    
    3. BUYING SIGNALS
       - Common triggers for evaluation
       - Budget patterns
       - Timeline patterns
    
    4. OBJECTION PATTERNS
       - Most common objections
       - How were they handled?
       - Any new objections emerging?
    
    5. PRODUCT INSIGHTS
       - Features requested
       - Use cases described
       - Integration requirements
    
    6. MARKETING AMMUNITION
       - Best quotes for case studies
       - Language patterns to use in copy
       - Pain points to address in content
    
    7. ACTIONABLE RECOMMENDATIONS
       - What should sales do differently?
       - What should product prioritize?
       - What should marketing create?
    
    Interviews:
    {json.dumps(recent_analyses, indent=2)}
    """
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=3000,
        messages=[{"role": "user", "content": prompt}]
    )
    
    return response.content[0].text

Real-World Applications​

For Sales Enablement​

def generate_objection_battlecard() -> str:
    """Generate objection handling guide from real calls"""
    
    objections = get_all_objections(months=3)
    
    prompt = f"""
    Based on {len(objections)} objections from real customer calls, create an objection handling battlecard.
    
    For each common objection:
    1. The objection (in customer's words)
    2. What they're really worried about
    3. Best response (based on calls where we overcame it)
    4. What NOT to say
    5. Follow-up question to ask
    
    Objection data:
    {json.dumps(objections, indent=2)}
    """
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2500,
        messages=[{"role": "user", "content": prompt}]
    )
    
    return response.content[0].text

For Product Teams​

def generate_product_feedback_summary() -> str:
    """Summarize product feedback from calls"""
    
    product_mentions = get_product_mentions(months=1)
    
    prompt = f"""
    Summarize product feedback from customer calls:
    
    1. FEATURE REQUESTS (ranked by frequency)
       - What's requested
       - Why they need it
       - How critical (nice-to-have vs deal-breaker)
    
    2. USABILITY FEEDBACK
       - What's confusing
       - What's loved
       - Suggestions for improvement
    
    3. INTEGRATION NEEDS
       - What tools need to integrate
       - Why (workflow context)
       - Priority
    
    4. COMPETITIVE GAPS
       - What competitors have that we don't
       - How important to buyers
       - Potential responses
    
    Product mentions:
    {json.dumps(product_mentions, indent=2)}
    """
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2000,
        messages=[{"role": "user", "content": prompt}]
    )
    
    return response.content[0].text

For Marketing​

def get_customer_language_for_copy(topic: str) -> str:
    """Get actual customer language for marketing copy"""
    
    relevant_quotes = search_quotes(topic)
    
    prompt = f"""
    You're a B2B copywriter. Extract usable language from these customer quotes about "{topic}".
    
    Provide:
    1. PAIN DESCRIPTIONS
       - How customers describe the problem (their words)
       - Emotional language used
       - Specific metrics/numbers mentioned
    
    2. VALUE LANGUAGE
       - How they describe what "good" looks like
       - Success metrics in their words
       - Transformation they're seeking
    
    3. HEADLINE IDEAS
       - 5 headlines using actual customer language
       - Focus on pain and transformation
    
    4. COPY SNIPPETS
       - Phrases that could go directly into copy
       - Statistics that could be cited
       - Before/after framings
    
    Quotes:
    {json.dumps(relevant_quotes, indent=2)}
    """
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1500,
        messages=[{"role": "user", "content": prompt}]
    )
    
    return response.content[0].text

Automation with OpenClaw​

Set up continuous analysis:

# openclaw.yaml
agents:
  interview-analyzer:
    prompt: |
      Analyze new discovery call transcripts as they come in.
      Extract structured insights and store in the knowledge base.
      Alert if any call reveals urgent product feedback or competitive intel.
    
    cron: "0 */4 * * *"  # Every 4 hours

  weekly-insights:
    prompt: |
      Every Monday, generate and distribute:
      1. Weekly interview insights report → #sales-insights
      2. Product feedback summary → #product
      3. Marketing language update → #marketing
    
    cron: "0 9 * * 1"  # Monday 9am

  insight-responder:
    prompt: |
      Answer questions about customer interviews using the knowledge base.
      Be specific, cite sources (which calls), and indicate confidence.
    
    triggers:
      - event: slack_mention
        filter: channel == "#sales-insights"