Extract clear win and loss reasons from deal notes, calls, and CRM fields. — Claude Skill

---

name: win-loss-reason-extraction description: 사용자가 영업 봇이 거래가 성사되거나 실패한 이유를 자동 분류하는 능력을 만들거나 개선하려 할 때 사용합니다. "승패 분석", "거래 결과", "실패 이유", "종료 이유", "거래 분류"를 언급할 때도 사용합니다.

승패 이유 추출

당신은 거래가 성사되거나 실패한 이유를 자동으로 추출하고 분류하는 영업 봇 구축 전문가입니다. 목표는 개발자가 결과에서 학습해 향후 성과를 개선하는 시스템을 만들도록 돕는 것입니다.

승패 추출이 중요한 이유

지식 격차

추출이 없을 때:
- "왜 졌나요?" "모르겠습니다"
- 같은 실수 반복
- 패턴 가시성 없음
- 직관 기반 전략

추출이 있을 때:
- 분류된 실패 이유
- 추세 식별
- 데이터 기반 개선
- 실행 가능한 인사이트

승리 이유 범주

일반적인 승리 이유

WIN_REASONS = {
    "product_fit": {
        "keywords": ["우리에게 꼭 필요한 것", "완벽하게 맞음", "우리 문제를 해결함"],
        "indicators": ["feature_match_high", "use_case_alignment"]
    },
    "price_value": {
        "keywords": ["공정한 가격", "좋은 가치", "가치가 있음", "ROI가 타당함"],
        "indicators": ["price_accepted", "roi_discussed_positively"]
    },
    "trust_relationship": {
        "keywords": ["신뢰함", "함께 일하기 좋음", "우리를 이해함"],
        "indicators": ["high_engagement", "personal_connection"]
    },
    "competitive_advantage": {
        "keywords": ["더 나음", "대신 선택함", "차별화됨"],
        "indicators": ["competitor_comparison_won", "unique_feature_mentioned"]
    },
    "timing": {
        "keywords": ["딱 맞는 시점", "긴급한 필요", "완벽한 타이밍"],
        "indicators": ["fast_sales_cycle", "urgency_expressed"]
    },
    "champion_advocacy": {
        "keywords": ["옹호함", "팀을 설득함", "내 추천"],
        "indicators": ["strong_champion", "internal_selling"]
    }
}

실패 이유 범주

일반적인 실패 이유

LOSS_REASONS = {
    "price": {
        "keywords": ["너무 비쌈", "예산 초과", "더 저렴한 옵션", "감당할 수 없음"],
        "indicators": ["price_objection", "budget_constraints"],
        "severity": "high"
    },
    "timing": {
        "keywords": ["타이밍이 나쁨", "지금은 아님", "나중에 가능", "내년에"],
        "indicators": ["timing_objection", "delayed_decision"],
        "severity": "medium"
    },
    "competitor": {
        "keywords": ["다른 곳으로 감", "선택함", "경쟁사가 이김", "[경쟁사] 사용"],
        "indicators": ["competitor_mentioned", "comparison_lost"],
        "severity": "high"
    },
    "no_decision": {
        "keywords": ["아무것도 하지 않음", "현재 상태 유지", "우선순위 아님"],
        "indicators": ["stalled", "no_urgency"],
        "severity": "medium"
    },
    "feature_gap": {
        "keywords": ["기능 누락", "지원하지 않음", "당신들에게 없는 X가 필요함"],
        "indicators": ["feature_request_unmet", "requirement_gap"],
        "severity": "high"
    },
    "bad_fit": {
        "keywords": ["우리에게 맞지 않음", "적합하지 않음", "필요한 것이 아님"],
        "indicators": ["poor_icp_match", "misaligned_use_case"],
        "severity": "medium"
    },
    "internal_issues": {
        "keywords": ["조직 개편", "합병", "예산 동결", "리더십 변경"],
        "indicators": ["external_factors", "company_change"],
        "severity": "low"
    },
    "lost_champion": {
        "keywords": ["담당자가 떠남", "더 이상 없음", "보고 체계 변경"],
        "indicators": ["champion_departed", "stakeholder_change"],
        "severity": "medium"
    }
}

추출 방법

대화 분석

def extract_reasons_from_conversation(conversation, outcome):
    reasons = []

    # 마지막 메시지 분석
    final_messages = conversation.messages[-5:]

    for message in final_messages:
        if message.sender == "prospect":
            # 이유 키워드와 대조
            if outcome == "lost":
                matched_reasons = match_loss_reasons(message.text)
            else:
                matched_reasons = match_win_reasons(message.text)

            reasons.extend(matched_reasons)

    # 대화 패턴 분석
    pattern_reasons = extract_pattern_based_reasons(conversation, outcome)
    reasons.extend(pattern_reasons)

    # 중복 제거와 순위화
    return rank_reasons(reasons)

def match_loss_reasons(text):
    matches = []
    for reason_code, config in LOSS_REASONS.items():
        for keyword in config["keywords"]:
            if keyword.lower() in text.lower():
                matches.append({
                    "reason": reason_code,
                    "confidence": 0.8,
                    "source": "keyword_match",
                    "evidence": text
                })
    return matches

패턴 기반 추출

def extract_pattern_based_reasons(conversation, outcome):
    reasons = []

    if outcome == "lost":
        # 가격 패턴
        if had_price_objection(conversation) and not resolved_price_objection(conversation):
            reasons.append({
                "reason": "price",
                "confidence": 0.7,
                "source": "pattern",
                "evidence": "해결되지 않은 가격 반론"
            })

        # 경쟁사 패턴
        competitor = detect_competitor_mention(conversation)
        if competitor and conversation.last_stage == "evaluation":
            reasons.append({
                "reason": "competitor",
                "confidence": 0.6,
                "source": "pattern",
                "evidence": f"평가 중 경쟁사 {competitor} 언급"
            })

        # 미결정 패턴
        if conversation.days_stalled > 30:
            reasons.append({
                "reason": "no_decision",
                "confidence": 0.5,
                "source": "pattern",
                "evidence": f"거래가 {conversation.days_stalled}일 동안 정체됨"
            })

    return reasons

LLM 기반 추출

def extract_reasons_with_llm(conversation, outcome):
    prompt = f"""
    이 {outcome} 영업 대화를 분석하고 결과의 주요 이유를 식별하세요.

    대화:
    {format_conversation(conversation)}

    제공할 내용:
    1. 주요 이유(다음 중 선택: {list_reasons(outcome)})
    2. 보조 이유(해당하는 경우)
    3. 신뢰도 수준(높음/중간/낮음)
    4. 대화에서 나온 증거

    JSON 형식으로 작성하세요.
    """

    response = llm.generate(prompt)
    return parse_reason_response(response)

이유 검증

신뢰도 점수화

def calculate_reason_confidence(reason, conversation):
    confidence = 0.5  # 기본 신뢰도

    # 직접 진술 보너스
    if reason["source"] == "explicit_statement":
        confidence += 0.3

    # 다중 신호 보너스
    signal_count = count_supporting_signals(reason, conversation)
    confidence += min(signal_count * 0.1, 0.3)

    # 최신성 보너스(최근 진술이 더 신뢰 가능)
    if reason.get("message_index") and reason["message_index"] >= len(conversation.messages) - 3:
        confidence += 0.1

    # 결과 설문과 교차 확인
    if matches_survey_response(reason, conversation.deal_id):
        confidence += 0.2

    return min(confidence, 1.0)

사람 검증 루프

def queue_for_validation(deal_id, extracted_reasons):
    """불확실한 추출 결과를 사람 검토 대상으로 표시합니다"""

    needs_review = []
    for reason in extracted_reasons:
        if reason["confidence"] < 0.7:
            needs_review.append(reason)

    if needs_review:
        create_review_task(
            deal_id=deal_id,
            reasons=needs_review,
            priority="medium" if len(needs_review) == 1 else "high"
        )

집계와 분석

추세 분석

def analyze_loss_trends(time_period):
    losses = get_lost_deals(time_period)

    # 이유별 집계
    reason_counts = Counter()
    for deal in losses:
        for reason in deal.loss_reasons:
            reason_counts[reason["reason"]] += 1

    # 비율 계산
    total = len(losses)
    reason_pcts = {r: c/total for r, c in reason_counts.items()}

    # 이전 기간과 비교
    prev_period = get_previous_period(time_period)
    prev_reason_pcts = analyze_loss_trends(prev_period)

    # 의미 있는 변화 식별
    trends = {}
    for reason, pct in reason_pcts.items():
        prev_pct = prev_reason_pcts.get(reason, 0)
        change = pct - prev_pct
        if abs(change) > 0.05:  # >5% change
            trends[reason] = {
                "current": pct,
                "previous": prev_pct,
                "change": change,
                "direction": "increasing" if change > 0 else "decreasing"
            }

    return {
        "distribution": reason_pcts,
        "trends": trends,
        "top_reasons": sorted(reason_pcts.items(), key=lambda x: -x[1])[:5]
    }

세그먼트별 분석

def analyze_by_segment(time_period):
    """세그먼트별 승패 이유를 분석합니다"""

    segments = ["smb", "mid_market", "enterprise"]
    analysis = {}

    for segment in segments:
        deals = get_deals(time_period, segment=segment)
        won = [d for d in deals if d.outcome == "won"]
        lost = [d for d in deals if d.outcome == "lost"]

        analysis[segment] = {
            "win_rate": len(won) / len(deals) if deals else 0,
            "top_win_reasons": get_top_reasons(won, "win"),
            "top_loss_reasons": get_top_reasons(lost, "loss"),
            "deal_count": len(deals)
        }

    return analysis

경쟁사 분석

def analyze_competitor_losses(time_period):
    """특정 경쟁사에 대한 패배를 분석합니다"""

    competitor_losses = get_deals(
        time_period,
        outcome="lost",
        reason="competitor"
    )

    by_competitor = {}
    for deal in competitor_losses:
        competitor = deal.competitor_name
        if competitor not in by_competitor:
            by_competitor[competitor] = {
                "count": 0,
                "reasons": [],
                "deal_sizes": []
            }

        by_competitor[competitor]["count"] += 1
        by_competitor[competitor]["reasons"].extend(deal.loss_details)
        by_competitor[competitor]["deal_sizes"].append(deal.deal_size)

    # 요약
    for competitor in by_competitor:
        by_competitor[competitor]["avg_deal_size"] = mean(
            by_competitor[competitor]["deal_sizes"]
        )
        by_competitor[competitor]["common_reasons"] = Counter(
            by_competitor[competitor]["reasons"]
        ).most_common(3)

    return by_competitor

실행 가능한 인사이트

인사이트 생성

def generate_win_loss_insights(analysis):
    insights = []

    # 가격 인사이트
    if analysis["top_loss_reasons"][0][0] == "price":
        insights.append({
            "type": "alert",
            "topic": "pricing",
            "insight": f"가격이 {analysis['top_loss_reasons'][0][1]:.0%}로 최상위 실패 이유입니다",
            "recommendation": "가격 전략 또는 가치 커뮤니케이션을 검토하세요"
        })

    # 경쟁사 인사이트
    competitor_losses = [r for r in analysis["distribution"] if r.startswith("competitor_")]
    if sum(analysis["distribution"].get(r, 0) for r in competitor_losses) > 0.3:
        insights.append({
            "type": "alert",
            "topic": "competitive",
            "insight": "패배의 30% 이상이 경쟁사 때문입니다",
            "recommendation": "경쟁 포지셔닝과 배틀카드를 업데이트하세요"
        })

    # 승리 인사이트
    if analysis.get("win_analysis", {}).get("top_win_reasons", []):
        top_win = analysis["win_analysis"]["top_win_reasons"][0]
        insights.append({
            "type": "positive",
            "topic": "winning",
            "insight": f"주요 승리 동인: {top_win[0]} ({top_win[1]:.0%})",
            "recommendation": f"메시징에서 {top_win[0]}을 강조하세요"
        })

    return insights

연동

CRM 업데이트

def update_crm_with_reasons(deal_id, reasons):
    """추출된 이유로 CRM을 업데이트합니다"""

    primary_reason = reasons[0] if reasons else None
    secondary_reason = reasons[1] if len(reasons) > 1 else None

    crm_update = {
        "Loss_Reason__c": primary_reason["reason"] if primary_reason else None,
        "Loss_Reason_Secondary__c": secondary_reason["reason"] if secondary_reason else None,
        "Loss_Details__c": "; ".join([r["evidence"] for r in reasons]),
        "Competitor_Lost_To__c": extract_competitor(reasons),
        "Reason_Confidence__c": primary_reason["confidence"] if primary_reason else None
    }

    crm_client.update_opportunity(deal_id, crm_update)