mcpField
C
conversation-velocity-optimization

conversation-velocity-optimization

github.com/louisblythe营销与增长190407 次安装40 周前更新
代码仓库

关于 conversation-velocity-optimization

conversation-velocity-optimization 面向构建销售机器人的开发者,指导系统根据潜在客户的回复节奏调整响应时机。内容涵盖速度检测、分级策略、渠道差异、节奏变化和效果指标。

主要功能

  1. 01测量并分类回复速度
  2. 02按回复节奏设定响应策略
  3. 03根据节奏调整内容长度
  4. 04区分邮件、SMS 和聊天
  5. 05检测变化并跟踪结果

适用场景

  1. 01为回复快慢不同的客户安排响应
  2. 02适配不同沟通渠道的回复
  3. 03应对客户互动节奏的变化
  4. 04评估响应时机的效果

安装

复制下面的命令,在终端中运行。

$npx skills add https://github.com/louisblythe/sales-skills --skill conversation-velocity-optimization

安装后在 Claude Code 中输入/conversation-velocity-optimization确认已加载。

详细介绍

对话速度优化

你是构建销售机器人方面的专家,擅长让机器人的回复速度匹配潜在客户的行为。你的目标是帮助开发者创建能够按照潜在客户偏好的节奏回复的系统——快速回应反应迅速的潜在客户,对从容应对的潜在客户则放慢节奏。

速度为何重要

速度不匹配问题
Scenario 1: Fast prospect, slow bot
Prospect replies in 30 seconds.
Bot takes 4 hours to respond.
Prospect: Already moved on, talking to competitor.

Scenario 2: Slow prospect, fast bot
Prospect replies after 2 days (thoughtful).
Bot responds in 2 minutes.
Prospect: Feels pressured, backs off.

Matching velocity = matching expectations.
速度优势
Fast responders get fast replies:
- Feels like real conversation
- Maintains momentum
- Shows responsiveness
- Capitalizes on interest window

Slow responders get measured replies:
- Doesn't feel pushy
- Respects their pace
- Matches their style
- Builds trust through patience

速度检测

衡量潜在客户的回复速度
def calculate_prospect_velocity(conversation):
    response_times = []

    for i, message in enumerate(conversation.messages):
        if message.sender == "prospect":
            # Time since our last message
            prev_message = find_previous_bot_message(conversation, i)
            if prev_message:
                response_time = message.timestamp - prev_message.timestamp
                response_times.append(response_time)

    if not response_times:
        return "unknown"

    avg_response = sum(response_times) / len(response_times)

    # Categorize velocity
    if avg_response < timedelta(minutes=5):
        return "very_fast"
    elif avg_response < timedelta(minutes=30):
        return "fast"
    elif avg_response < timedelta(hours=4):
        return "moderate"
    elif avg_response < timedelta(hours=24):
        return "slow"
    else:
        return "very_slow"
速度类别
Very Fast (<5 min):
- In active conversation mode
- High engagement
- Expect immediate responses
- Likely on mobile or at computer

Fast (5-30 min):
- Engaged but multitasking
- Checking messages regularly
- Expect quick responses
- Window of high interest

Moderate (30 min - 4 hours):
- Busy but interested
- Checking periodically
- Standard business pace
- Normal response time acceptable

Slow (4-24 hours):
- Low priority or busy
- Daily email checker
- No rush expected
- Patience appreciated

Very Slow (>24 hours):
- Very busy or low interest
- Needs multiple days
- Don't push frequency
- Long-term nurture
实时更新速度
class VelocityTracker:
    def __init__(self, prospect_id):
        self.prospect_id = prospect_id
        self.velocity_history = []
        self.current_velocity = "unknown"

    def update_on_response(self, response_time):
        self.velocity_history.append({
            "time": response_time,
            "timestamp": datetime.now()
        })

        # Weight recent responses more heavily
        recent = self.velocity_history[-5:]  # Last 5
        weighted_avg = self.calculate_weighted_average(recent)

        self.current_velocity = self.categorize(weighted_avg)
        return self.current_velocity

    def get_recommended_reply_time(self):
        VELOCITY_TARGETS = {
            "very_fast": timedelta(minutes=2),
            "fast": timedelta(minutes=10),
            "moderate": timedelta(hours=1),
            "slow": timedelta(hours=4),
            "very_slow": timedelta(hours=12),
            "unknown": timedelta(hours=1)  # Default
        }
        return VELOCITY_TARGETS[self.current_velocity]

回复时机策略

面对回复非常迅速的潜在客户
Strategy: Match their energy

- Respond within 2-5 minutes
- Use conversational, quick messages
- Keep momentum going
- Multiple short exchanges OK
- Feels like real-time chat

"Got it! So you're saying [x]—that makes sense.
Quick question: [follow-up]"
面对回复迅速的潜在客户
Strategy: Quick but not instant

- Respond within 10-30 minutes
- Thorough but concise
- Don't overwhelm with info
- Keep conversation moving

"Thanks for the quick reply! Based on what you
mentioned about [x], here's what I'd suggest..."
面对回复速度中等的潜在客户
Strategy: Standard business pace

- Respond within 1-4 hours
- More comprehensive responses
- Include relevant details
- Don't expect immediate follow-up

"Hi [Name], thanks for getting back to me.
I've put together some thoughts on [topic]..."
面对回复较慢的潜在客户
Strategy: Patient and thorough

- Respond within 4-12 hours
- Very comprehensive
- Anticipate follow-up questions
- Don't send rapid follow-ups

"Hi [Name], I know you're busy so I wanted to
give you a complete picture in one message..."
面对回复非常慢的潜在客户
Strategy: Measured and respectful

- Respond within 12-24 hours
- Complete, standalone messages
- Don't send multiple messages
- Long intervals between sequences

"Hi [Name], following up from last week.
I've attached everything you'd need to
evaluate this at your own pace..."

自适应回复系统

动态时机引擎
class AdaptiveResponder:
    def __init__(self):
        self.velocity_tracker = {}

    def should_respond_now(self, prospect_id, message_ready_at):
        tracker = self.get_tracker(prospect_id)
        target_time = tracker.get_recommended_reply_time()

        # Calculate when to send
        send_at = message_ready_at + target_time

        # Add small human-like variation
        variance = random.uniform(-0.2, 0.3) * target_time
        send_at += variance

        # Respect business hours
        send_at = adjust_to_business_hours(send_at)

        return send_at

    def schedule_response(self, prospect_id, response):
        send_at = self.should_respond_now(
            prospect_id,
            datetime.now()
        )

        if send_at <= datetime.now():
            # Send immediately
            return self.send_now(response)
        else:
            # Schedule for later
            return self.schedule_send(response, send_at)
按速度调整内容
def adjust_content_for_velocity(response, velocity):
    if velocity in ["very_fast", "fast"]:
        # Shorter, punchier
        response = shorten_response(response)
        response = add_quick_cta(response)

    elif velocity in ["slow", "very_slow"]:
        # More comprehensive
        response = add_context(response)
        response = anticipate_questions(response)
        response = make_standalone(response)

    return response

各渠道的回复速度

电子邮件回复速度
Typical email pace:
- Fast: Same-day response
- Normal: Within 24 hours
- Slow: 2-3 days

Adjust:
- Fast emailers: Reply within hours
- Slow emailers: Don't expect same-day
- Very slow: Weekly cadence max
短信回复速度
Typical SMS pace:
- Fast: Within minutes
- Normal: Within hours
- Slow: Same day

SMS generally expects faster:
- Even "slow" SMS prospects expect same-day
- Don't let SMS responses go overnight
- Match their speed closely
聊天回复速度
Chat expectation:
- Real-time conversation
- Responses within seconds-minutes
- Leaving chat = ending conversation

Chat-specific:
- Always respond fast
- Typing indicators helpful
- Don't make them wait

速度变化

检测速度变化
def detect_velocity_shift(tracker):
    recent = tracker.velocity_history[-3:]
    historical = tracker.velocity_history[:-3]

    if len(recent) < 2 or len(historical) < 2:
        return None

    recent_avg = average(recent)
    historical_avg = average(historical)

    if recent_avg < historical_avg * 0.5:
        return "accelerating"
    elif recent_avg > historical_avg * 2:
        return "decelerating"
    else:
        return "stable"
应对速度变化
Velocity accelerating:
"Great to catch you! Since you're available,
want to just knock this out now?"
→ Capitalize on their attention

Velocity decelerating:
"I know you're busy—no rush on a response.
Here's everything you need when you have time."
→ Reduce pressure

模拟真人的变化

避免机械式的回复时机
Too consistent:
- Always responds in exactly 5 minutes
- Feels automated
- Lacks authenticity

Better:
- 3-7 minute range for "fast"
- Some responses quicker, some slower
- Occasional "I'm looking into this"

Add variance:
base_time + random(-20%, +30%)
模拟打字
For real-time channels:

1. Show typing indicator
2. Duration based on message length
3. Small variance in timing
4. Occasional corrections/edits

Makes bot feel human, not instant.

指标

速度匹配表现
Track:
- Velocity match rate (did we match their speed?)
- Response satisfaction by velocity tier
- Conversion rate by velocity tier
- Engagement continuation rate

Optimize:
- Tighten timing accuracy
- Identify optimal variance
- Channel-specific tuning
速度影响分析
Compare outcomes:
- Fast-matched vs mismatched
- Slow-matched vs too-fast responses

Questions:
- Does matching improve conversion?
- What's the optimal response time per tier?
- Does faster always help?

边缘情况

突然有空
Slow prospect suddenly responds fast:

"Let me grab you while you're here—
any questions I can answer right now?"

Capitalize on rare attention window.
时间紧迫
Even for slow prospects, respond fast when:
- They mention urgency
- Decision deadline mentioned
- Competitor comparison active
- "I need to know by..."

Override normal velocity for urgency.
非工作时间的活动
Prospect responding at 11pm:
- They're choosing to engage
- Match their energy? Or wait?

Options:
- Auto-respond acknowledging receipt
- Full response during business hours
- Match if high intent detected

评论

支持 Markdown