Your best deal just went dark.

The champion replied to every email for two months, took three demos, got the contract last Tuesday. Then silence.

By the time someone notices, it's been 9 days. The deal is dead. The champion took another job. You find out from LinkedIn.

This happens constantly because CRM data is passive. It waits for someone to go look at it. No one does until it's too late.

The fix: Real-time alerts in Slack where your team already lives.

This guide shows you how to build an intelligent alerting system with OpenClaw that catches pipeline problems before they become pipeline losses.

Why Slack for Sales Alerts?​

Slack Is Where Attention Lives​

Your reps check CRM when they have to. They check Slack constantly.

• Average Slack user checks 20+ times daily
• Most teams have Slack on phone with notifications
• Real-time visibility into team activity

CRM Alerts Are Broken​

Most CRM notification systems:

• Email alerts (goes to spam or ignored)
• In-app badges (only see when you login)
• Daily digests (too late for urgent issues)

Slack Is Actionable​

A Slack alert isn't just information—it's a jumping off point:

🚨 DEAL ALERT: Acme Corp - $48K
Contact went dark (9 days no engagement)

Champion: Sarah Chen (VP Sales)
Last activity: Email opened Feb 2, no reply
Deal stage: Negotiation (was: Verbal commit)

Actions:
[📞 Call Now] [📧 Draft Email] [📋 View in HubSpot]

One click from alert to action.

What to Alert On​

Tier 1: Immediate Alerts (Real-Time)​

These need instant notification:

Tier 2: Same-Day Alerts (Batched)​

Important but not urgent:

Tier 3: Trends and Summaries​

Context for leadership:

Building with OpenClaw​

Step 1: Connect to Your CRM​

OpenClaw needs to watch your CRM for changes. Using HubSpot as an example:

# openclaw config
integrations:
  hubspot:
    portalId: "YOUR_PORTAL_ID"
    privateAppToken: ${HUBSPOT_TOKEN}
    watchEntities:
      - deals
      - contacts
      - activities

Step 2: Define Alert Rules​

Create an alert agent that watches for specific patterns:

// alert-rules.js
const alertRules = {
  // Champion job change (via email bounce or LinkedIn)
  championJobChange: {
    trigger: 'contact.job_title_changed OR contact.email_bounced',
    condition: (contact, deal) => deal.amount > 20000 && deal.stage !== 'Closed',
    severity: 'critical',
    channel: '#deal-alerts',
    dmOwner: true,
    message: (contact, deal) => `
🚨 *CHAMPION ALERT: Job Change Detected*
*Deal:* ${deal.name} — $${deal.amount.toLocaleString()}
*Contact:* ${contact.name} (${contact.old_title} → ${contact.new_title || 'Unknown'})
*Action Required:* Verify contact status, identify new champion

[View Deal](${deal.hubspot_url}) | [LinkedIn Search](https://linkedin.com/search?keywords=${encodeURIComponent(contact.name)})
`
  },

  // Deal gone dark
  dealGoneDark: {
    trigger: 'deal.last_activity_age > 5 days',
    condition: (deal) => deal.amount > 10000 && !['Closed Won', 'Closed Lost'].includes(deal.stage),
    severity: 'warning',
    channel: '#pipeline-health',
    message: (deal) => `
⚠️ *Deal Gone Quiet:* ${deal.name}
*Amount:* $${deal.amount.toLocaleString()}
*Last Activity:* ${deal.last_activity_date} (${deal.days_since_activity} days ago)
*Stage:* ${deal.stage}

[📞 Quick Action: Schedule Follow-up](${deal.hubspot_url})
`
  },

  // Contract viewed
  contractViewed: {
    trigger: 'document.viewed AND document.type = "contract"',
    condition: (doc, deal) => true,
    severity: 'positive',
    channel: '#deal-alerts',
    dmOwner: true,
    message: (doc, deal) => `
🔥 *Hot Signal: Contract Viewed*
*Deal:* ${deal.name} — $${deal.amount.toLocaleString()}
*Viewer:* ${doc.viewer_email}
*Time on Doc:* ${doc.view_duration}

Strike while hot! [Call Now](tel:${deal.contact_phone})
`
  },

  // Large deal stage change
  largeStageChange: {
    trigger: 'deal.stage_changed',
    condition: (deal) => deal.amount > 50000,
    severity: 'info',
    channel: '#deal-alerts',
    message: (deal) => `
📊 *Pipeline Update:* ${deal.name}
*Amount:* $${deal.amount.toLocaleString()}
*Stage:* ${deal.old_stage} → ${deal.new_stage}
*Owner:* ${deal.owner_name}
`
  }
};

Step 3: Set Up the Watcher Agent​

OpenClaw runs the alerting logic:

# openclaw agent config
agents:
  deal_watcher:
    name: "Deal Watcher"
    schedule:
      realtime:
        - hubspot.deal.updated
        - hubspot.contact.updated
        - hubspot.email.sent
      cron:
        - "*/15 * * * *"  # Every 15 min for batch checks
    
    task: |
      For each CRM event:
      1. Check against all alert rules
      2. If triggered, format and send to appropriate Slack channel
      3. If dmOwner, also DM the deal owner
      4. Log alert to tracking table (avoid duplicates)
      
      For batch checks (cron):
      1. Query deals with no activity > threshold
      2. Group by owner
      3. Send summary to #pipeline-health

Step 4: Configure Slack Integration​

integrations:
  slack:
    botToken: ${SLACK_BOT_TOKEN}
    channels:
      deal-alerts: "C0123456789"
      pipeline-health: "C0123456790"
      sales-leadership: "C0123456791"
    
    messageDefaults:
      unfurl_links: false
      unfurl_media: false

Step 5: Add Smart Deduplication​

Nobody wants the same alert 47 times:

// dedup.js
const alertCache = new Map();

function shouldSendAlert(alertKey, cooldownMinutes = 60) {
  const lastSent = alertCache.get(alertKey);
  const now = Date.now();
  
  if (lastSent && (now - lastSent) < cooldownMinutes * 60 * 1000) {
    return false; // Skip, sent recently
  }
  
  alertCache.set(alertKey, now);
  return true;
}

// Usage
const alertKey = `dark_deal_${deal.id}`;
if (shouldSendAlert(alertKey, 1440)) { // Once per day max
  sendSlackAlert(channel, message);
}

Advanced Patterns​

Pattern 1: Engagement Scoring Alerts​

Combine multiple signals into a score:

const engagementScore = (deal) => {
  let score = 0;
  
  // Positive signals
  if (deal.email_opened_last_7d) score += 10;
  if (deal.link_clicked_last_7d) score += 20;
  if (deal.meeting_scheduled) score += 30;
  if (deal.pricing_page_view) score += 25;
  if (deal.contract_viewed) score += 40;
  
  // Negative signals
  if (deal.days_since_activity > 7) score -= 20;
  if (deal.emails_no_reply > 3) score -= 15;
  if (deal.meeting_no_show) score -= 30;
  
  return score;
};

// Alert on score drops
if (deal.previous_score - deal.current_score > 30) {
  sendAlert('engagement_drop', deal);
}

Pattern 2: Multi-Threading Alerts​

When you only have one contact at a company:

const singleThreadAlert = {
  trigger: 'deal.stage = "Proposal" AND deal.contacts.count = 1',
  message: (deal) => `
⚠️ *Single Thread Risk:* ${deal.name}
Only contact: ${deal.contacts[0].name} (${deal.contacts[0].title})
Recommendation: Get intro to economic buyer before negotiation

[Research Contacts](https://linkedin.com/company/${deal.company_linkedin}/people)
`
};

Pattern 3: Competitive Intelligence Alerts​

Watch for competitor mentions:

// Scan email content, call notes, Gong transcripts
const competitorMentioned = {
  trigger: 'activity.body CONTAINS competitor_keywords',
  competitors: ['Apollo', '6sense', 'ZoomInfo', 'Demandbase'],
  message: (activity, deal, competitor) => `
🎯 *Competitor Mentioned:* ${competitor}
*Deal:* ${deal.name} — $${deal.amount}
*Context:* ${activity.snippet}

[View Full Activity](${activity.url}) | [Competitive Battlecard](${battlecard_url(competitor)})
`
};

Pattern 4: Renewal Risk Alerts​

For customer success teams:

const renewalRisk = {
  trigger: 'deal.type = "renewal" AND deal.close_date < 60_days_out',
  condition: (deal) => {
    const riskFactors = [];
    if (deal.nps_score < 7) riskFactors.push('Low NPS');
    if (deal.support_tickets_open > 3) riskFactors.push('Open tickets');
    if (deal.usage_trend === 'declining') riskFactors.push('Usage down');
    if (deal.champion_left) riskFactors.push('Champion departed');
    return riskFactors.length >= 2;
  },
  message: (deal, risks) => `
🚨 *Renewal at Risk:* ${deal.company}
*ARR:* $${deal.amount} | *Renewal:* ${deal.close_date}
*Risk Factors:* ${risks.join(', ')}

[Customer Health Dashboard](${deal.cs_dashboard_url})
`
};

Organizing Your Channels​

Recommended Structure​

#deal-alerts          — Critical real-time alerts (AEs + managers)
#pipeline-health      — Daily summaries and trends (AEs + managers)
#sales-leadership     — High-level pipeline updates (leadership)
#cs-alerts            — Customer success notifications (CS team)
#data-quality         — Bounces, duplicates, etc. (ops team)

Channel Hygiene​

Keep channels useful:

• #deal-alerts: Only urgent, actionable items. Max 10-15/day.
• #pipeline-health: Batched digests. Once or twice daily.
• #sales-leadership: Weekly summaries unless something major.

If a channel gets too noisy, people mute it. Then it's useless.

Measuring Alert Effectiveness​

Track whether alerts actually help:

const alertMetrics = {
  // Track each alert type
  alertsSent: {},
  alertsActedOn: {},  // User clicked action button
  outcomeAfterAlert: {},  // Did the deal status improve?
  
  // Calculate value
  alertROI: (alertType) => {
    const sent = alertsSent[alertType];
    const acted = alertsActedOn[alertType];
    const saved = outcomeAfterAlert[alertType].filter(o => o === 'saved');
    
    return {
      actionRate: acted / sent,
      saveRate: saved / acted,
      dealValueSaved: saved.reduce((sum, d) => sum + d.amount, 0)
    };
  }
};

Good benchmarks:

• Action rate (clicked button): >40%
• Alert-to-save rate: >15%
• Average response time: <2 hours for critical alerts

Common Mistakes to Avoid​

Alert Fatigue​

The biggest risk. If everything is an alert, nothing is.

Fix it:

• Ruthlessly prioritize what deserves real-time alerts
• Use batching for everything else
• Track channel mute rates—if >30%, you're too noisy

Missing Context​

An alert without context creates work:

❌ BAD:
"Deal Acme Corp updated"

✅ GOOD:
"🔥 Deal Acme Corp ($48K) — Champion viewed contract 3x in last hour
Last touch: Pricing call Tuesday
Decision: Expected this week
[Call Sarah Now] [View Timeline]"

No Action Path​

Every alert should answer: "What do I do next?"

Include buttons/links to:

• Call the contact
• Send a pre-drafted email
• View the full record
• Escalate to manager

Ignoring Time Zones​

Don't send alerts at 3am. Configure quiet hours:

const shouldAlertNow = (owner, alertPriority) => {
  const ownerTz = owner.timezone || 'America/Chicago';
  const localHour = moment().tz(ownerTz).hour();
  
  // Critical alerts: always
  if (alertPriority === 'critical') return true;
  
  // Others: business hours only
  return localHour >= 8 && localHour <= 20;
};

Integrating with MarketBetter​

MarketBetter's Daily SDR Playbook already identifies the highest-priority accounts and actions. Add Slack alerts to:

• Push today's top priorities — Morning notification of must-do tasks
• Alert on engagement — When a playbook account shows buying signals
• Track follow-through — Confirm reps are working suggested accounts

Want to see intelligent alerting built into your SDR workflow? Book a demo and we'll show you how real-time signals drive real-time action.

Getting Started​

Week 1: Foundation​

1. Set up OpenClaw with HubSpot/Salesforce connection
2. Create #deal-alerts channel
3. Configure 3 critical alert types
4. Test with your own deals

Week 2: Expand​

1. Add engagement scoring
2. Create #pipeline-health for digests
3. Add action buttons to alerts
4. Roll out to full sales team

Week 3: Optimize​

1. Measure action rates
2. Tune thresholds (too many? too few?)
3. Add advanced patterns (multi-threading, competitor)
4. Document what's working

Ongoing​

• Review alert effectiveness monthly
• Add new patterns as you learn what matters
• Remove alerts no one acts on
• Share wins in team meetings

Related Reading​

• Build a 24/7 Pipeline Monitor with OpenClaw — Full monitoring system
• OpenClaw + HubSpot: Ultimate CRM Automation — Deep integration guide
• OpenClaw Setup Guide for GTM Teams — Getting started with OpenClaw

The deals you save are the ones you see in time. See them in Slack, where you're already looking.

Your biggest deals don't close in the CRM. They close in the conversations—the Slack messages, the quick syncs, the "hey, can you jump on this call?" moments.

But most sales teams still treat Slack as an afterthought. Deal updates live in CRM fields that nobody checks. Critical signals get buried in email threads. By the time someone notices a deal is at risk, it's too late.

What if Slack became your deal cockpit instead of your distraction?

With OpenClaw, you can build intelligent deal rooms that:

• Auto-populate with relevant deal context
• Alert the right people at the right moments
• Surface risks before they become losses
• Coordinate multi-stakeholder deals seamlessly

The Problem with Manual Deal Collaboration​

Here's how most sales teams collaborate on deals today:

Scenario: The $80K Deal​

Week 1: AE creates opportunity in CRM. Mentions it in #sales channel. "Got a good one, Acme Corp, $80K potential."

Week 3: AE needs SE help. Slacks the SE directly. SE asks 15 questions that are already in the CRM. AE spends 20 minutes catching them up.

Week 5: Prospect goes quiet. AE mentions in standup. Manager asks for context. AE gives verbal update that's different from CRM. Nobody writes it down.

Week 7: Champion reaches out to support with a question. Support doesn't know there's an active deal. Responds with generic answer. AE finds out 3 days later.

Week 9: Deal slips. Everyone asks "what happened?" Nobody has the full picture.

Sound familiar?

The AI-Powered Deal Room​

Here's the alternative: an AI-managed Slack channel for every deal above a certain threshold.

What It Does​

1. Auto-creates a channel when deals hit Stage 2 or $50K+
2. Populates context from CRM, emails, calls, and support
3. Invites relevant people based on deal stage and needs
4. Sends intelligent alerts when signals change
5. Summarizes status on request or on schedule
6. Logs updates back to CRM from Slack conversations

The Experience​

#deal-acme-corp-80k

🤖 OpenClaw Deal Bot
──────────────────────────────
📋 DEAL OVERVIEW
Company: Acme Corp
Amount: $80,000
Stage: Demo Scheduled
Close Date: Mar 15, 2026
Owner: Sarah Chen

👥 BUYING COMMITTEE
• John Smith (VP Sales) — Champion
• Lisa Wong (CFO) — Economic Buyer
• Mike Johnson (IT) — Technical Evaluator

📊 ENGAGEMENT SCORE: 78/100 ⬆️ (+12 this week)

📝 RECENT ACTIVITY
• [Today] Call scheduled for Thursday 2pm
• [Yesterday] John opened proposal email 4x
• [3 days ago] Lisa viewed pricing page

⚠️ RISKS
• CFO hasn't attended any calls yet
• Competitor (Warmly) mentioned in discovery

🎯 RECOMMENDED ACTIONS
1. Invite CFO to demo call
2. Prepare competitive displacement deck
──────────────────────────────

Now everyone in the channel has context. No catch-up needed.

Building This with OpenClaw​

Let's build the automated deal room system.

Step 1: Channel Creation Trigger​

# deal_room_manager.py
import os
from slack_sdk import WebClient
from datetime import datetime

slack = WebClient(token=os.environ["SLACK_BOT_TOKEN"])

DEAL_ROOM_THRESHOLD = 50000
STAGE_THRESHOLD = "demo_scheduled"

def should_create_deal_room(deal: dict) -> bool:
    """Determine if deal qualifies for a deal room"""
    return (
        deal["amount"] >= DEAL_ROOM_THRESHOLD or
        deal["stage"] == STAGE_THRESHOLD
    ) and not deal.get("deal_room_channel")

def create_deal_room(deal: dict) -> str:
    """Create Slack channel for deal"""
    
    # Generate channel name
    company_slug = slugify(deal["company_name"])[:20]
    amount_k = int(deal["amount"] / 1000)
    channel_name = f"deal-{company_slug}-{amount_k}k"
    
    # Create channel
    result = slack.conversations_create(
        name=channel_name,
        is_private=True
    )
    channel_id = result["channel"]["id"]
    
    # Set channel topic
    slack.conversations_setTopic(
        channel=channel_id,
        topic=f"🎯 {deal['company_name']} | ${deal['amount']:,} | {deal['stage']} | Owner: {deal['owner_name']}"
    )
    
    # Add initial members
    member_ids = get_deal_room_members(deal)
    slack.conversations_invite(
        channel=channel_id,
        users=member_ids
    )
    
    # Post initial context
    post_deal_overview(channel_id, deal)
    
    # Update CRM with channel link
    crm_client.update_deal(deal["id"], {
        "deal_room_channel": channel_id,
        "deal_room_created": datetime.now().isoformat()
    })
    
    return channel_id

def get_deal_room_members(deal: dict) -> list:
    """Determine who should be in the deal room"""
    
    members = [deal["owner_slack_id"]]  # Always include owner
    
    # Add manager
    if deal["amount"] >= 100000:
        members.append(get_manager_slack_id(deal["owner_id"]))
    
    # Add SE if technical requirements
    if deal.get("requires_technical_validation"):
        members.append(get_available_se_slack_id())
    
    # Add SDR if they sourced it
    if deal.get("sourced_by_slack_id"):
        members.append(deal["sourced_by_slack_id"])
    
    return list(set(members))  # Dedupe

Step 2: Context Posting​

def post_deal_overview(channel_id: str, deal: dict):
    """Post initial deal context to channel"""
    
    # Gather all context
    contacts = get_deal_contacts(deal["id"])
    activities = get_deal_activities(deal["id"], limit=10)
    risks = analyze_deal_risks(deal)
    engagement_score = calculate_engagement_score(deal)
    
    # Format message
    blocks = [
        {
            "type": "header",
            "text": {"type": "plain_text", "text": "📋 DEAL OVERVIEW"}
        },
        {
            "type": "section",
            "fields": [
                {"type": "mrkdwn", "text": f"*Company:*\n{deal['company_name']}"},
                {"type": "mrkdwn", "text": f"*Amount:*\n${deal['amount']:,}"},
                {"type": "mrkdwn", "text": f"*Stage:*\n{deal['stage']}"},
                {"type": "mrkdwn", "text": f"*Close Date:*\n{deal['close_date']}"},
            ]
        },
        {"type": "divider"},
        {
            "type": "header",
            "text": {"type": "plain_text", "text": "👥 BUYING COMMITTEE"}
        },
        {
            "type": "section",
            "text": {"type": "mrkdwn", "text": format_contacts(contacts)}
        },
        {"type": "divider"},
        {
            "type": "header",
            "text": {"type": "plain_text", "text": f"📊 ENGAGEMENT SCORE: {engagement_score}/100"}
        },
        {"type": "divider"},
        {
            "type": "header",
            "text": {"type": "plain_text", "text": "📝 RECENT ACTIVITY"}
        },
        {
            "type": "section",
            "text": {"type": "mrkdwn", "text": format_activities(activities)}
        }
    ]
    
    if risks:
        blocks.extend([
            {"type": "divider"},
            {
                "type": "header",
                "text": {"type": "plain_text", "text": "⚠️ RISKS"}
            },
            {
                "type": "section",
                "text": {"type": "mrkdwn", "text": format_risks(risks)}
            }
        ])
    
    slack.chat_postMessage(
        channel=channel_id,
        blocks=blocks,
        text=f"Deal overview for {deal['company_name']}"
    )

Step 3: Intelligent Alerts​

This is where AI makes the difference:

from anthropic import Anthropic

claude = Anthropic()

ALERT_ANALYSIS_PROMPT = """
You are a sales deal analyst monitoring deal health. Given the recent activity and deal context, determine if an alert should be sent to the deal room.

Alert ONLY for significant events:
- Champion goes dark (no engagement in 7+ days after regular contact)
- New stakeholder enters (especially C-level or procurement)
- Competitor mentioned
- Timeline changes (close date moved)
- Negative sentiment in communications
- Unusual engagement spike (could indicate urgency or comparison shopping)
- Risk factors emerging

DO NOT alert for:
- Normal activity cadence
- Minor email opens
- Routine meetings scheduled
- Small CRM updates

If alerting, provide:
1. Alert severity (🔴 critical, 🟡 warning, 🟢 positive)
2. Clear headline
3. Context (what happened)
4. Recommended action
5. Who should be tagged
"""

def analyze_deal_event(deal: dict, event: dict) -> dict | None:
    """Determine if event warrants an alert"""
    
    recent_context = get_deal_recent_context(deal["id"])
    
    prompt = f"""
    Deal context:
    {json.dumps(deal, indent=2)}
    
    Recent history:
    {json.dumps(recent_context, indent=2)}
    
    New event:
    {json.dumps(event, indent=2)}
    
    Should this trigger an alert? If yes, format the alert. If no, respond with "NO_ALERT".
    """
    
    response = claude.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=500,
        system=ALERT_ANALYSIS_PROMPT,
        messages=[{"role": "user", "content": prompt}]
    )
    
    result = response.content[0].text
    
    if "NO_ALERT" in result:
        return None
    
    return parse_alert(result)

def post_alert(channel_id: str, alert: dict):
    """Post alert to deal room"""
    
    severity_emoji = {
        "critical": "🔴",
        "warning": "🟡",
        "positive": "🟢"
    }
    
    emoji = severity_emoji.get(alert["severity"], "ℹ️")
    
    message = f"""
{emoji} *{alert['headline']}*

{alert['context']}

*Recommended Action:* {alert['action']}
"""
    
    # Tag relevant people
    if alert.get("tag_users"):
        mentions = " ".join([f"<@{uid}>" for uid in alert["tag_users"]])
        message = f"{mentions}\n\n{message}"
    
    slack.chat_postMessage(
        channel=channel_id,
        text=message
    )

Step 4: Status Updates​

def post_daily_summary(channel_id: str, deal: dict):
    """Post daily deal status summary"""
    
    # Gather 24-hour activity
    activities = get_deal_activities(deal["id"], hours=24)
    score_change = get_engagement_score_change(deal["id"], hours=24)
    
    # Skip if no activity
    if not activities and score_change == 0:
        return
    
    summary = f"""
📊 *Daily Update* | {datetime.now().strftime('%b %d')}

*Engagement Score:* {deal['engagement_score']}/100 ({'+' if score_change >= 0 else ''}{score_change})

*Activity:*
{format_activities(activities) if activities else "No new activity"}

*Stage:* {deal['stage']}
*Days to Close Date:* {(deal['close_date'] - datetime.now()).days}
"""
    
    slack.chat_postMessage(
        channel=channel_id,
        text=summary
    )

def handle_status_request(channel_id: str, deal: dict, question: str = None):
    """Handle @bot status request in channel"""
    
    context = gather_full_deal_context(deal["id"])
    
    if question:
        prompt = f"""
        Deal context:
        {json.dumps(context, indent=2)}
        
        Question: {question}
        
        Provide a concise answer based on the deal data.
        """
    else:
        prompt = f"""
        Deal context:
        {json.dumps(context, indent=2)}
        
        Provide a brief status summary:
        1. Current health assessment (1-2 sentences)
        2. Key recent developments
        3. Biggest risk right now
        4. Recommended next action
        """
    
    response = claude.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=400,
        messages=[{"role": "user", "content": prompt}]
    )
    
    slack.chat_postMessage(
        channel=channel_id,
        text=response.content[0].text
    )

Step 5: OpenClaw Configuration​

# openclaw.yaml
agents:
  deal-room-manager:
    prompt: |
      You manage Slack deal rooms for the sales team. Your responsibilities:
      
      1. Create deal rooms when deals qualify (>$50K or Stage 2+)
      2. Post initial context and overview
      3. Monitor for alert-worthy events
      4. Post daily summaries for active deals
      5. Respond to status requests
      
      Be helpful but not noisy. Only alert when it matters.
    
    memory: true
    
    triggers:
      - event: deal_stage_change
      - event: deal_amount_change
      - event: email_received
      - event: meeting_completed
      - event: support_ticket_created

  deal-room-responder:
    prompt: |
      When someone asks a question in a deal room, provide helpful answers
      using the deal context. Be concise and actionable.
    
    triggers:
      - event: slack_mention
        filter: channel.startsWith("deal-")

cron:
  daily-summaries:
    schedule: "0 8 * * 1-5"  # 8am weekdays
    action: run_daily_deal_summaries

The Impact​

Here's what teams see after implementing AI deal rooms:

Before​

• 30+ minutes per deal for context gathering
• 3-5 people asking "what's the status?" per week per deal
• Risks surfaced at pipeline reviews (often too late)
• No single source of deal truth

After​

• Instant context for anyone entering the deal
• Zero status questions (it's all in the channel)
• Risks surfaced in real-time when they emerge
• Slack channel IS the deal truth

Best Practices​

1. Set Clear Thresholds​

Don't create deal rooms for every deal. You'll create noise and nobody will pay attention. Start with:

• Deals over $50K, OR
• Deals in Stage 3+, OR
• Strategic accounts (regardless of size)

2. Auto-Archive on Close​

When deals close (won or lost), automatically archive the channel after posting a summary. Keeps workspace clean.

3. Sync Both Ways​

Updates in Slack should flow back to CRM. If someone posts "Call pushed to Friday," the CRM close date should update.

4. Train the Team​

The bot is only useful if people use it. Do a 15-minute training on:

• How to ask for status
• What triggers alerts
• How to update deal info via Slack

5. Review and Refine​

Monthly, check:

• Are alerts useful or noisy?
• Are deal rooms being used?
• What context is missing?

Adjust thresholds and prompts based on feedback.

Getting Started​

1. Day 1: Set up Slack bot with basic channel creation
2. Week 1: Add context posting and member management
3. Week 2: Implement alert system
4. Week 3: Add status summaries and Q&A
5. Month 2: Refine based on team feedback

The technology is straightforward. The value is in execution.

Want AI That Actually Drives Deals?​

MarketBetter doesn't just alert you to deal signals—it tells your SDRs exactly what to do next. From signal to action, automatically.

Book a Demo →

Related Posts:

• Slack Deal Alerts with OpenClaw
• AI Pipeline Forecasting
• Real-Time Competitive Intel Alerts

Generic AI gives generic results.

You've tried ChatGPT for sales emails. The output sounds like... ChatGPT. Professional. Pleasant. Forgettable.

Your prospects can smell AI-generated content from a mile away. And they delete it.

The secret isn't better prompts for generic AI—it's training AI that understands YOUR business.

This guide shows you how to build custom AI agents that know your ICP, speak in your voice, understand your competitive landscape, and produce content that actually sounds like your team wrote it.

Why "Off-the-Shelf" AI Fails for Sales​

The Generic Problem​

Default AI models know everything about everything—and nothing about your specific:

• ICP characteristics — Who your best customers actually are
• Pain points — What problems you uniquely solve
• Voice — How your brand communicates
• Objections — What prospects actually say, not textbook objections
• Process — Your specific sales stages and handoffs
• Competitors — Your actual competitive landscape

The Cost of Generic​

When AI doesn't understand your context:

Generic wastes time and damages brand perception.

The Three Levels of AI Customization​

You don't need to "train" a model from scratch. There are easier approaches:

Level 1: Prompt Engineering (No Code)​

Give the AI detailed context in every prompt. Free, immediate, good for testing.

Best for: Small teams, experimentation, single-use tasks

Level 2: System Prompts + Memory (Low Code)​

Create persistent agent personas with custom instructions. Requires OpenClaw or similar.

Best for: Repeatable tasks, team-wide deployment, consistent voice

Level 3: Fine-Tuning (Technical)​

Train a model on your actual data. Requires examples and some technical setup.

Best for: High-volume tasks, unique terminology, proprietary voice

Let's build each.

Level 1: Prompt Engineering​

The 80/20 of AI customization. Most teams never need more than this.

The Context Stack​

Every great prompt includes:

1. ROLE — Who the AI is acting as
2. CONTEXT — Background about your business
3. TASK — What you want it to do
4. EXAMPLES — What good output looks like
5. CONSTRAINTS — What to avoid
6. FORMAT — How to structure output

Example: Sales Email Prompt​

## ROLE
You are a senior SDR at MarketBetter, a B2B sales intelligence platform.

## CONTEXT
Our ICP:
- VP/Director of Sales at B2B SaaS companies, 50-500 employees
- Pain: SDR efficiency, lead quality, personalizing outbound at scale
- Our differentiation: We don't just show WHO to call—we tell them WHAT to do

Competitors: Apollo (no workflow), 6sense (enterprise pricing), ZoomInfo (data only)

Our voice: Direct, helpful, slightly irreverent. No corporate speak. 
We sound like a smart friend who happens to know a lot about sales.

## TASK
Write a cold email to a prospect based on the research provided.

## EXAMPLES OF OUR VOICE
Good: "Your SDRs are drowning in data. Here's a life raft."
Good: "Most sales tools show you a firehose. We hand you a glass of water."
Bad: "I hope this email finds you well."
Bad: "We are a leading provider of sales intelligence solutions."

## CONSTRAINTS
- Never start with "I hope this email finds you well"
- Never use "leverage," "synergy," or "circle back"
- Maximum 125 words
- Must include specific detail from prospect research
- End with a question, not a meeting request

## FORMAT
Subject line, then body. No salutation ("Hi Name" is fine but not required).

Building a Prompt Library​

Create prompts for every common task:

/prompts
  /email
    cold_outreach_v3.md
    follow_up_after_meeting.md
    breakup_email.md
  /linkedin
    connection_request.md
    first_message.md
    inmail_template.md
  /call
    discovery_questions.md
    objection_handling.md
    voicemail_script.md
  /research
    account_briefing.md
    competitive_analysis.md
    champion_mapping.md

Prompt Versioning​

Track what works:

# cold_outreach_v3.md
---
version: 3.2
last_updated: 2026-02-09
performance:
  reply_rate: 8.2%
  a/b_tested: true
  sample_size: 1,247
changes_from_v2:
  - Added pattern-interrupt examples
  - Removed "reach out" from banned phrases
  - Shortened max length from 150 to 125 words
---

[prompt content...]

Level 2: System Prompts + Memory​

When you need consistent behavior across sessions.

Creating Agent Personas​

In OpenClaw, create a dedicated agent:

# agents/sdr_agent.yaml
name: "SDR Assistant"
emoji: "🎯"

soul: |
  You are the SDR Assistant for MarketBetter.
  
  ## Your Personality
  - Direct and efficient (SDRs are busy)
  - Helpful but not sycophantic
  - Knowledgeable about our ICP and process
  
  ## What You Know
  - Our ICP: VP/Director Sales at B2B SaaS, 50-500 employees
  - Our competitors and how we beat them
  - Our sales process and stage definitions
  - Our messaging and voice guidelines
  
  ## What You Do
  - Write emails in our voice
  - Prep accounts for calls
  - Handle objection scripting
  - Research prospects
  
  ## What You Don't Do
  - Book meetings directly (point to Calendly)
  - Access competitor pricing (it changes)
  - Make promises about features

memory:
  # Load company context
  - /knowledge/icp.md
  - /knowledge/competitors.md
  - /knowledge/voice-guidelines.md
  - /knowledge/objection-playbook.md

Building the Knowledge Base​

Create documents the agent references:

# /knowledge/icp.md

## Ideal Customer Profile

### Primary Persona: VP/Director of Sales
- Company size: 50-500 employees
- Industry: B2B SaaS, Tech, IoT
- Team structure: Has SDR team (3-15 SDRs)
- Tech stack: HubSpot or Salesforce, uses 3+ sales tools

### Buying Triggers
- Just raised Series A/B (scaling sales team)
- Hired new sales leadership (mandate to improve)
- SDR turnover problems (efficiency is suffering)
- Competitor using us (fear of falling behind)

### Common Objections
1. "We already have Apollo/ZoomInfo"
   → They give you data. We give you a playbook.
   
2. "Our current process works"
   → What's your SDR ramp time? What's their daily call-to-meeting ratio?
   
3. "Don't have budget"
   → Typically saves 30% of SDR time. What's that worth annually?

Adding Memory​

Let agents remember across sessions:

# OpenClaw agent with memory
memory_config:
  enabled: true
  paths:
    - memory/daily_notes/
    - memory/account_context/
  
  auto_remember:
    - prospect_preferences  # "Sarah prefers morning calls"
    - past_interactions    # "Sent 3 emails, no response"
    - custom_context       # "Mentioned they use Salesforce"

Now when you ask "Draft a follow-up for Sarah at Acme," the agent remembers your history.

Level 3: Fine-Tuning​

When you need AI that sounds exactly like your best performers.

When to Fine-Tune​

Fine-tuning is worth it when:

• You have 500+ examples of great output
• Consistency matters more than flexibility
• You're running high-volume tasks (1000s daily)
• Your terminology is unique

Preparing Training Data​

Collect examples of excellent work:

// training_examples.jsonl
{"messages": [
  {"role": "system", "content": "You write cold emails for MarketBetter."},
  {"role": "user", "content": "Write email for: Sarah Chen, VP Sales, Acme Corp, 200 employees, just raised Series B"},
  {"role": "assistant", "content": "Subject: Series B → what's next for sales?\n\nSarah,\n\nSaw the funding news—congrats. The next 6 months are make-or-break for scaling the team.\n\nMost companies at your stage drown their new SDRs in data. \"Here's 10,000 leads, figure it out.\"\n\nThe ones that win give them a playbook. Who to call, what to say, why today.\n\nThat's what we built. Happy to show you what top-performing SDR teams at your stage actually do differently.\n\n— [Name]"}
]}

{"messages": [
  {"role": "system", "content": "You write cold emails for MarketBetter."},
  {"role": "user", "content": "Write email for: James Wilson, Director Sales Ops, TechCorp, competitor using Apollo"},
  {"role": "assistant", "content": "Subject: Apollo gives you data. Now what?\n\nJames,\n\nAppollo's solid for contact data. But your SDRs still wake up wondering: who do I actually call first? What do I say?\n\nThat's the gap we fill. Not more data—a daily playbook. \"Call Sarah at Acme, mention their recent Series B, ask about scaling challenges.\"\n\nSDRs spend time selling, not researching.\n\n30 min to show you how it works with your current Apollo setup?\n\n— [Name]"}
]}

Running Fine-Tuning (OpenAI)​

# Upload training file
openai api files.create -f training_data.jsonl -p fine-tune

# Start fine-tuning
openai api fine_tuning.jobs.create \
  -m gpt-4o-mini \
  -t file-abc123

# Check status
openai api fine_tuning.jobs.retrieve -j ftjob-xyz789

# Use fine-tuned model
curl https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "ft:gpt-4o-mini:marketbetter:sdr-emails:2026-02",
    "messages": [{"role": "user", "content": "Write email for: ..."}]
  }'

Fine-Tuning Best Practices​

Data quality > quantity 100 excellent examples beat 1000 mediocre ones.

Diverse examples Include different scenarios, personas, objections.

Negative examples Show what NOT to do:

{"messages": [
  {"role": "user", "content": "Write email..."},
  {"role": "assistant", "content": "I hope this email finds you well! I wanted to reach out because..."}
], "weight": -1}  // Negative weight = avoid this pattern

Regular retraining Your voice evolves. Retrain quarterly with fresh examples.

The Feedback Loop​

Custom AI gets better when you close the loop:

Tracking Output Quality​

// Log every AI output
const logOutput = {
  prompt_id: 'cold_email_v3',
  input: prospectContext,
  output: generatedEmail,
  user_edits: whatTheySent,
  edit_distance: calculateDiff(output, user_edits),
  outcome: {
    sent: true,
    opened: true,
    replied: true,
    meeting_booked: true
  }
};

Learning from Edits​

If reps consistently edit the same things:

// Weekly analysis
const commonEdits = analyzeEdits(logs);

// Example output:
// "Users removed 'hope this helps' in 67% of emails"
// "Users shortened first paragraph in 45% of cases"
// "Users added specific data point in 78% of cases"

// Update prompt based on patterns

A/B Testing Prompts​

Run experiments on prompt versions:

const promptExperiment = {
  control: 'cold_email_v3',
  variant: 'cold_email_v4_shorter',
  allocation: { control: 0.5, variant: 0.5 },
  metrics: ['reply_rate', 'edit_distance', 'meeting_rate'],
  sample_size_needed: 500,
  auto_promote_threshold: { reply_rate: 0.10 }  // 10% reply = auto-win
};

Building Your Training Pipeline​

Phase 1: Document What Works (Week 1-2)​

1. Interview top performers: How do they write emails? Handle objections?
2. Collect 50+ examples of excellent work
3. Document your voice guidelines
4. Write your ICP and competitor profiles

Phase 2: Build Basic Prompts (Week 3-4)​

1. Create prompt templates for top 5 use cases
2. Test with 3-5 team members
3. Iterate based on feedback
4. Build prompt library in git

Phase 3: Deploy Agents (Month 2)​

1. Set up OpenClaw with your prompts
2. Create agent personas with memory
3. Connect to CRM for context injection
4. Train team on using agents

Phase 4: Continuous Improvement (Ongoing)​

1. Track output quality and edits
2. A/B test prompt variations
3. Update knowledge base monthly
4. Consider fine-tuning when you hit 500+ examples

Common Mistakes to Avoid​

Over-Engineering Early​

Don't fine-tune on day one. Start with prompts. Get wins. Then optimize.

Ignoring the Human Layer​

AI assists, humans approve. Always have a rep review before sending.

Static Prompts​

Your market changes. Your product changes. Your voice evolves. Update prompts regularly.

No Feedback Loop​

If you're not measuring output quality, you're not improving.

Integrating with MarketBetter​

MarketBetter's Daily SDR Playbook uses trained AI models that understand your specific:

• Account scoring — Tuned to YOUR closed-won patterns
• Message generation — Matches YOUR voice and style
• Objection handling — Based on YOUR competitive landscape

Want to see custom AI in action? Book a demo and we'll show you how trained AI powers personalization at scale.

Further Reading​

• AI Email Personalization at Scale — Apply these techniques to email
• Claude 200K Context for Sales Workflows — Leverage large context windows
• 10 Codex Prompts That 10x SDR Productivity — Ready-to-use prompt templates
• The AI SDR Tech Stack — How it all fits together

Generic AI is table stakes. Custom AI is your competitive advantage. Start building yours.

The difference between a mediocre AI response and a game-changing one? The prompt.

With 57% of enterprises now using AI agents for multi-stage sales workflows and 80% reporting measurable ROI, the SDRs who master prompting are pulling ahead fast. They're not working harder—they're working smarter by getting 10x better outputs from the same AI tools everyone else has access to.

Here's the thing: anyone can send 10,000 emails for pennies now. The SDRs crushing quota aren't just using AI—they're using it strategically with prompts that deliver genuinely personalized, insight-driven outreach.

Below are 10 copy-paste prompts I use daily. Each one is battle-tested, includes template variables you can customize, and comes with a real example of what great output looks like.

Why Good Prompts Actually Matter​

Most SDRs treat ChatGPT or Claude like a magic 8-ball: ask a vague question, get a vague answer.

Bad prompt: "Write me a sales email"

Good prompt: Specific context + clear task + desired format + constraints

The difference in output quality is staggering. A well-crafted prompt transforms AI from a generic text generator into your personal sales research analyst, copywriter, and strategist—all in one.

Think of prompts like instructions to a brilliant but literal-minded assistant. The more context and specificity you provide, the more valuable the output.

The 10 Prompts​

1. Lead Research Deep Dive​

Use this before any outreach to uncover insights that make your emails impossible to ignore.

You are a B2B sales research analyst. I need comprehensive research on [CONTACT_NAME], [ROLE] at [COMPANY].

Research and provide:
1. **Company Overview**: What does [COMPANY] do? Recent news, funding, acquisitions in the last 12 months
2. **Role Context**: What are typical priorities and challenges for a [ROLE] at a company this size?
3. **Potential Pain Points**: Based on their industry ([INDUSTRY]) and company stage, what problems might they face that [YOUR_PRODUCT] could solve?
4. **Personalization Hooks**: Any recent LinkedIn posts, podcast appearances, awards, or public content I can reference?
5. **Recommended Angle**: What's the single most compelling reason this person should take a meeting?

Be specific. Avoid generic statements. If you don't know something, say so rather than guessing.

Example output:

"Jake recently posted on LinkedIn about struggling with lead quality from ZoomInfo. His company just raised Series B—likely scaling the sales team. Angle: position around the pain of scaling outbound while maintaining personalization quality."

2. Hyper-Personalized First Email​

Transform your research into emails that actually get replies.

Write a cold email to [CONTACT_NAME], [ROLE] at [COMPANY].

**Context about them:**
[PASTE YOUR RESEARCH OR KEY FACTS]

**What we sell:**
[YOUR_PRODUCT] helps [TARGET_PERSONA] to [MAIN_VALUE_PROP].

**Rules:**
- Maximum 100 words
- Open with something specific to them (NOT "I hope this finds you well")
- One clear pain point, one clear value statement
- End with a low-friction CTA (not "Let me know if you'd like to chat")
- Tone: confident but not pushy, conversational but professional
- No buzzwords like "synergy," "leverage," or "unlock"

Write 3 variations with different opening hooks.

Pro tip: Always generate multiple variations. The first option is rarely the best.

3. Objection Handling Scripts​

Prepare for common pushbacks before they happen.

I'm an SDR selling [YOUR_PRODUCT] to [TARGET_PERSONA].

The prospect just said: "[OBJECTION]"

Give me:
1. **Why they're saying this**: What's the real concern behind this objection?
2. **Acknowledge & Pivot**: A response that validates their concern without being defensive
3. **Proof Point**: A stat, case study reference, or third-party validation I could use
4. **Redirect Question**: A question that moves the conversation forward

Keep responses conversational—I'm on a call, not writing an essay.

Common objections to prep:

• "We already use [COMPETITOR]"
• "We don't have budget right now"
• "Send me some information" (the brush-off)
• "I need to talk to my team"
• "We're not looking at this until Q3"

4. Pre-Call Research Brief​

Never walk into a call blind again. Run this 10 minutes before every meeting.

I have a call in 10 minutes with [CONTACT_NAME], [ROLE] at [COMPANY].

Create a 1-page call prep brief:

**Quick Company Context:**
- What they do (1 sentence)
- Size, funding stage, recent news
- Tech stack if known

**This Person:**
- Career background (quick summary)
- Likely priorities in their role
- Any content they've published

**Conversation Starters:**
- 2-3 specific things I can reference to build rapport

**Likely Pain Points:**
- Based on role + company context

**Questions I Should Ask:**
- 3 discovery questions tailored to their situation

**Red Flags to Watch:**
- What might indicate this isn't a good fit?

Keep it scannable—bullet points, not paragraphs.

5. LinkedIn Connection Request​

Stand out in a sea of "I'd love to connect" messages.

Write a LinkedIn connection request to [CONTACT_NAME], [ROLE] at [COMPANY].

**What I know about them:**
[ONE SPECIFIC FACT OR OBSERVATION]

**Rules:**
- Maximum 280 characters (LinkedIn limit)
- Reference something specific about them
- Give a reason to connect (not "I'd love to pick your brain")
- No pitch, no ask—just genuine connection
- Sound like a human, not a sales bot

Write 3 options.

Example output:

"Hey Sarah—saw your take on intent data in that RevOps Co-op thread. Spot on. Would love to connect with folks who actually get the signal-vs-noise problem. — [NAME]"

6. Follow-Up Email Sequence​

Because 80% of deals require 5+ touches, but most SDRs give up after 2.

I sent a cold email to [CONTACT_NAME] at [COMPANY] about [TOPIC/VALUE_PROP].

No response after [X] days.

Write follow-up email #[2/3/4] that:
- Doesn't just "bump" or "circle back" (those are lazy)
- Adds NEW value: a relevant insight, resource, or angle
- Is shorter than the previous email
- Has a different CTA approach
- Maintains my dignity (no begging, guilt-tripping, or "I guess you're not interested")

**Previous email summary:**
[1-2 SENTENCES ON WHAT YOU SENT]

**Optional new hook:**
[ANY NEW NEWS, TRIGGER, OR INSIGHT ABOUT THEIR COMPANY]

Follow-up framework:

• Email 2: New angle + social proof
• Email 3: Relevant content/resource share
• Email 4: Breakup email (creates urgency without desperation)

7. Competitive Battlecard​

Know your competition cold.

I sell [YOUR_PRODUCT] and often compete against [COMPETITOR].

Create a quick competitive battlecard:

**[COMPETITOR] Overview:**
- What they do, who they serve
- Pricing model if known
- Key features/strengths

**Where They Win:**
- What are they genuinely good at?
- What types of companies choose them?

**Where We Win:**
- Based on [YOUR_DIFFERENTIATORS], where do we have an advantage?

**Common Objections When They're Incumbent:**
- What will prospects say if they're already using [COMPETITOR]?

**Displacement Talk Track:**
- How do I respectfully position against them without bashing?

**Trap Questions:**
- Questions I can ask that highlight our strengths vs. their weaknesses?

For a deeper dive on AI tool comparisons, check out our Claude vs ChatGPT for Sales Teams breakdown.

8. Meeting Prep & Demo Customization​

Tailor your demo to what actually matters to this specific buyer.

I'm preparing a demo for [CONTACT_NAME], [ROLE] at [COMPANY].

**What we've learned in discovery:**
[KEY PAIN POINTS, GOALS, OR REQUIREMENTS]

**Their industry:** [INDUSTRY]
**Company size:** [SIZE]
**Current solution:** [WHAT THEY USE TODAY]

Help me prepare:

1. **Demo Flow**: What features should I prioritize and in what order?
2. **Tailored Talk Track**: How do I frame each feature in terms of THEIR specific problems?
3. **ROI Story**: What metrics would resonate most with a [ROLE]?
4. **Landmines to Avoid**: Based on their current setup, what might cause objections?
5. **Next Steps to Propose**: What's a logical follow-up that advances the deal?

9. Account Prioritization Matrix​

Stop wasting time on accounts that will never close.

I have [X] accounts in my territory. Help me prioritize them.

Here's the data:
[PASTE ACCOUNT LIST WITH: Company name, industry, size, last activity, any signals]

Score and rank these accounts based on:

1. **Fit Score**: How well do they match our ICP ([DESCRIBE YOUR ICP])?
2. **Timing Signals**: Any indicators they're in-market now?
3. **Access**: Do we have a path to decision-makers?
4. **Deal Size Potential**: What's the likely ACV?

Output as a tiered list:
- **Tier 1 (Hot)**: Work these daily
- **Tier 2 (Warm)**: Work these weekly
- **Tier 3 (Nurture)**: Monthly touch, not priority

Include a 1-sentence reasoning for each Tier 1 account.

10. End-of-Day Summary & Tomorrow's Plan​

Close out strong, start tomorrow with momentum.

Here's what happened in my sales day:

**Calls made:** [X]
**Emails sent:** [X]
**Replies received:** [X]
**Meetings booked:** [X]
**Deals advanced:** [LIST]
**Stalled deals:** [LIST]
**Notable wins:** [ANY]
**Frustrations:** [ANY]

Help me:

1. **Reflect**: What worked well today? What patterns do I see?
2. **Diagnose**: If I'm behind on [SPECIFIC_METRIC], what might be causing it?
3. **Prioritize Tomorrow**: Based on my pipeline, what are the 3 highest-leverage activities for tomorrow?
4. **Prepare**: Any specific accounts or tasks I should prep tonight?

Be direct and actionable—I want to leave with a clear plan.

How to Use These Prompts Effectively​

Having great prompts is only half the battle. Here's how to get maximum value:

1. Build Your Prompt Library​

Save these in a doc, Notion, or your CRM snippets. The SDRs who move fastest have their prompts one click away.

2. Customize the Variables​

The [BRACKETS] are your personalization points. The more specific you make them, the better your output. Generic inputs = generic outputs.

3. Iterate on Outputs​

First output is a draft, not a final. Ask follow-up questions like:

• "Make it shorter"
• "Make the CTA more casual"
• "Give me a version for a technical buyer"

4. Layer Your AI Usage​

Use prompt #1 (research) → feed that output into prompt #2 (email). Chain them for compounding quality.

5. Learn From What Works​

When an email gets a reply or a call goes well, reverse engineer it. Update your prompts with what's working.

Bonus: Template Variables Cheat Sheet​

Keep these placeholders consistent across all your prompts:

The Real Unlock: AI + Human Connection​

Here's what most people get wrong about AI in sales:

The goal isn't to replace human connection—it's to create more time for it.

When you use AI to handle the research, first drafts, and analysis, you free up mental bandwidth for what actually closes deals: genuine conversations, creative problem-solving, and building real relationships.

With AI, anyone can send 10,000 emails for pennies. Human connection is almost the premium currency left in B2B.

These prompts help you do the busywork faster so you can invest your energy where it actually matters.

Ready to Go Beyond Prompts?​

Want to see these prompting principles built into an actual AI-powered sales workflow? Book a demo of MarketBetter and see how we turn intent signals into personalized outreach—automatically.

Or if you're the DIY type, check out our tutorial on how to build your own AI SDR using tools you already have.

Now go make those prompts work for you. Bookmark this page, copy what resonates, and start experimenting. The SDRs who master AI prompting today will be tomorrow's sales leaders.

Generic demos kill deals.

You walk in with your standard deck. You show features in your standard order. You use your standard case studies. The prospect politely nods along, asks a few questions, then ghosts you for three weeks.

Meanwhile, your competitor did their homework. They opened with the prospect's exact pain point. They showed the feature that solves it. They referenced a customer in the same industry with the same problem.

Guess who got the deal?

Demo personalization isn't optional anymore. But doing it manually for every prospect takes hours. AI changes that math entirely.

The Demo Personalization Problem​

What great demo prep looks like:

• Research the prospect's company (news, earnings, job postings)
• Understand each attendee's role and likely priorities
• Identify their specific pain points from discovery call
• Select relevant case studies and proof points
• Customize deck with their logo, data, and challenges
• Prepare for likely objections
• Create custom follow-up materials

Time required: 2-4 hours per demo

What actually happens:

• Skim their website for 5 minutes
• Use the same deck you always use
• Wing the objection handling
• Hope for the best

Time spent: 10 minutes

AI lets you get 90% of the value with 10% of the time.

The AI Demo Prep Stack​

Overview​

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│   Pre-Demo      │────▶│   AI Research   │────▶│   Outputs       │
│   Trigger       │     │   & Assembly    │     │   For Rep       │
└─────────────────┘     └─────────────────┘     └─────────────────┘
         │                      │                       │
     Calendar              Claude/Codex              - Research brief
     24h before            + Web search              - Custom slides
                           + CRM data                - Objection prep
                                                     - Attendee profiles

Trigger: 24 Hours Before Demo​

Set up a cron job that runs 24 hours before every scheduled demo:

# OpenClaw cron configuration
cron:
  - name: "Demo Prep Automation"
    schedule: "0 9 * * *"  # Daily at 9am
    prompt: |
      Check calendar for demos tomorrow.
      For each demo:
      1. Pull CRM data and discovery notes
      2. Research company and attendees
      3. Generate personalized brief
      4. Recommend case studies
      5. Create objection prep
      6. Send to rep via Slack

Component 1: Company Deep-Dive​

async def research_company(company_name: str, company_domain: str) -> dict:
    """Research a company for demo preparation."""
    
    research_prompt = f"""
    Research \{company_name\} ({company_domain}) for an upcoming sales demo.
    
    Find and summarize:
    
    ## Company Overview
    - Industry and business model
    - Size (employees, revenue if public)
    - Recent funding or major events
    
    ## Current Challenges (likely)
    - Based on their job postings, what are they building?
    - Based on news, what problems are they solving?
    - Industry-wide challenges affecting them
    
    ## Technology Stack
    - What tools do they likely use? (from job postings)
    - Integration opportunities
    
    ## Competitive Context
    - Who are their competitors?
    - What differentiates them?
    
    ## Trigger Events
    - Recent news worth mentioning
    - Leadership changes
    - Product launches
    
    Output as structured JSON for use in demo prep.
    """
    
    # Use Claude with web search capability
    response = await claude_with_search(research_prompt)
    return parse_research(response)

Component 2: Attendee Profiles​

async def research_attendees(attendees: list[dict]) -> list[dict]:
    """Research each demo attendee."""
    
    profiles = []
    for attendee in attendees:
        profile_prompt = f"""
        Research {attendee['name']} ({attendee['title']}) at {attendee['company']}.
        
        Find:
        - Background (previous roles, education)
        - Recent LinkedIn posts or activity
        - Likely priorities based on their role
        - How our product helps someone in their position
        - Potential concerns they might have
        
        Output: 3-paragraph brief for the sales rep.
        """
        
        profile = await claude_with_search(profile_prompt)
        profiles.append({
            'name': attendee['name'],
            'title': attendee['title'],
            'profile': profile,
            'suggested_talking_points': extract_talking_points(profile)
        })
    
    return profiles

Component 3: Personalized Slide Recommendations​

Based on the research, recommend which slides to use and in what order:

def recommend_slides(research: dict, discovery_notes: str) -> list[dict]:
    """Recommend slide order based on prospect context."""
    
    prompt = f"""
    Based on this prospect research and discovery notes, 
    recommend the optimal demo flow.
    
    Research: {json.dumps(research)}
    Discovery Notes: {discovery_notes}
    
    Available slides:
    1. Company Overview
    2. Problem Statement (generic)
    3. Problem Statement (industry-specific variations)
    4. Product Demo - Visitor ID
    5. Product Demo - SDR Playbook
    6. Product Demo - Smart Dialer
    7. Product Demo - AI Chatbot
    8. Case Study - SaaS
    9. Case Study - IoT
    10. Case Study - Professional Services
    11. Pricing Overview
    12. Implementation Timeline
    13. ROI Calculator
    
    Output:
    - Recommended order (list of slide numbers)
    - For each slide: talking points personalized to this prospect
    - Slides to skip and why
    """
    
    return claude_complete(prompt)