Imported from gooseworks-ai/goose-skills (skills/sales/composites/sales-coaching/SKILL.md). Install upstream with npx skills add gooseworks-ai/goose-skills --skill sales-coaching. Copyright stays with the author.

Sales Coaching

An AI coach that studies everything you do in sales — your emails, your calls, your deals — finds the patterns in what works and what doesn't, and gives you specific, actionable coaching to get better.

This isn't generic sales advice ("always be closing"). It's coaching derived from YOUR data: your top-performing emails, your winning calls, your successful deal patterns, your most common objection fumbles, and your specific product's market.

What makes this different from sequence-performance:

The other composite analyzes the work. This one coaches the worker.

When to Auto-Load

Load this composite when:

• User says "how can I improve my sales", "coach me", "what am I doing wrong", "sales coaching", "help me sell better"
• User says "review my selling style", "analyze my calls", "what patterns do you see in my sales"
• User asks "why am I losing deals", "why aren't people responding", "what are my best emails doing differently"
• After a bad quarter/month and the user wants to diagnose personal performance
• As a periodic (monthly/quarterly) self-improvement exercise

Step 0: Configuration (One-Time Setup)

User Profile

Role options:

• "sdr" — Focus on prospecting, outreach, qualification, meeting booking
• "ae" — Focus on discovery, demos, negotiation, closing
• "founder" — Focus on everything (wearing multiple hats)
• "sales_leader" — Focus on team patterns, not just individual

Data Sources

Store config in the current working directory or wherever the user prefers.

Step 1: Collect Sales Data

Purpose: Pull all available sales data for analysis. The more data types available, the richer the coaching. But the system works with whatever is available.

Input Contract

data_sources: { ... }                 # From config
analysis_window: integer              # Days to look back
user_role: string                     # From config

Data Collection Matrix

Pull from each configured source:

Email Data

email_data: {
  campaigns: [
    {
      name: string
      date_range: { start: string, end: string }
      sequence: [
        {
          touch: integer
          subject: string
          body: string
          sent: integer
          opens: integer
          replies: integer
        }
      ]
      replies: [
        {
          sender: string
          sender_title: string
          reply_text: string
          category: string            # positive, objection, not interested, etc.
          touch_triggered: integer
        }
      ]
    }
  ]
  total_campaigns: integer
  total_emails_sent: integer
  total_replies: integer
  overall_reply_rate: percentage
}

Call Data

call_data: {
  calls: [
    {
      date: string
      prospect_name: string
      prospect_company: string
      call_type: string               # discovery, demo, follow-up, negotiation
      duration_minutes: integer
      transcript: string | null       # Full transcript if available
      recording_url: string | null    # Recording link if available
      outcome: string                 # "next step agreed", "no next step", "closed won", "closed lost"
      notes: string | null            # Post-call notes
    }
  ]
  total_calls: integer
  avg_duration: float
  outcome_distribution: { ... }
}

Pipeline Data

pipeline_data: {
  deals: [
    {
      name: string
      company: string
      stage: string
      created_date: string
      close_date: string | null
      outcome: "open" | "won" | "lost"
      loss_reason: string | null
      amount: number | null
      days_in_pipeline: integer
      source: string | null           # How the deal originated
      touches_before_close: integer | null
    }
  ]
  total_deals: integer
  win_rate: percentage
  avg_cycle_days: float
  avg_deal_size: number | null
}

Output Contract

collected_data: {
  email_data: { ... } | null
  call_data: { ... } | null
  pipeline_data: { ... } | null
  data_richness: "full" | "partial" | "minimal"
  data_summary: string                # "Analyzing X campaigns, Y calls, Z deals over N days"
}

Human Checkpoint

## Data Collected

| Source | Available | Volume |
|--------|-----------|--------|
| Email campaigns | Yes | X campaigns, Y emails sent, Z replies |
| Call transcripts | Yes/No | X calls, Y hours |
| Pipeline deals | Yes | X deals (W won, L lost, O open) |

Analysis window: [start] to [end]
Data richness: [full/partial/minimal]

Proceed with analysis? (Y/n)

Step 2: Analyze Email Performance Patterns

Purpose: Go beyond campaign-level metrics. Find patterns in what makes YOUR best emails work and YOUR worst emails fail. Pure LLM reasoning.

Process

A) Identify Top-Performing Emails

Across all campaigns, find:

• Highest reply-rate subject lines — What do they have in common?
• Highest reply-rate email bodies — What patterns exist?
• Emails that generated positive replies — What specifically triggered interest?
• Emails that generated meetings — The gold standard. What did these say?

For each top performer, extract:

B) Identify Worst-Performing Emails

Same analysis on the bottom performers:

• What do low-reply emails have in common?
• Are there anti-patterns? (Long emails, generic openers, weak CTAs, no proof)
• Is there a consistent flaw across campaigns?

C) Compare Winners vs. Losers

D) Objection Pattern Analysis

Across all replies classified as objections:

E) Reply Sentiment Analysis

Key question: Is the ratio of positive-to-negative replies improving over time? Are you getting better at writing emails that generate interest, or are you stagnating?

Output Contract

email_patterns: {
  top_performers: {
    common_patterns: string[]
    best_subject_lines: [ { subject: string, reply_rate: percentage, pattern: string } ]
    best_openers: [ { opener: string, campaign: string, why_it_works: string } ]
    winning_proof_points: string[]
    winning_ctas: string[]
    winning_tone: string
    winning_framework: string
  }

  bottom_performers: {
    common_anti_patterns: string[]
    worst_subject_lines: [ { subject: string, reply_rate: percentage, issue: string } ]
    common_mistakes: string[]
  }

  winner_vs_loser: {
    dimensions: [ { dimension: string, winners: string, losers: string, gap: string } ]
    biggest_differentiator: string
  }

  objection_patterns: {
    most_common: { objection: string, count: integer, handle_effectiveness: string }
    handleable_objections: [ { objection: string, best_handle: string, conversion_rate: string } ]
    terminal_objections: [ { objection: string, implication: string } ]
  }

  sentiment_trend: {
    direction: "improving" | "stable" | "declining"
    evidence: string
  }

  email_skill_grade: "A" | "B" | "C" | "D" | "F"
  email_skill_summary: string
}

Step 3: Analyze Call Performance Patterns

Purpose: If call transcripts or recordings are available, analyze how the user performs on calls. If no call data exists, skip this step.

Process

A) Structural Analysis (From Transcripts)

For each call transcript, measure:

B) Discovery Quality Analysis

From call transcripts, evaluate:

C) Objection Handling on Calls

For each objection raised during calls:

D) Demo / Presentation Analysis

If demo calls exist:

E) Winning vs. Losing Call Patterns

Compare calls that led to progression (next step, closed won) vs. calls that stalled or lost:

Output Contract

call_patterns: {
  structural: {
    avg_talk_ratio: percentage
    avg_longest_monologue_seconds: integer
    avg_questions_per_call: float
    filler_word_frequency: "low" | "moderate" | "high"
    common_fillers: string[]
    avg_call_duration: float
  }

  discovery_quality: {
    pain_discovery_rate: percentage    # % of calls where real pain was uncovered
    impact_quantification_rate: percentage
    decision_process_mapped_rate: percentage
    next_step_agreed_rate: percentage
    common_gaps: string[]             # What's consistently missed in discovery
  }

  objection_handling: {
    objections_per_call: float
    acknowledgment_rate: percentage   # % of times objection was properly acknowledged
    exploration_rate: percentage      # % of times the objection was explored before handling
    resolution_rate: percentage       # % of times the objection was successfully handled
    weakest_objection_type: string    # Which type of objection you handle worst
    best_objection_type: string       # Which type you handle best
  }

  demo_quality: {
    feature_dumping_detected: boolean
    prospect_engagement_level: "high" | "moderate" | "low"
    customization_level: "tailored" | "semi-generic" | "generic"
    common_demo_mistakes: string[]
  } | null

  winning_vs_losing: {
    key_differences: [ { dimension: string, winners: string, losers: string } ]
    biggest_predictor: string         # Single biggest differentiator between winning and losing calls
  }

  call_skill_grade: "A" | "B" | "C" | "D" | "F"
  call_skill_summary: string
} | null

Step 4: Analyze Deal Patterns

Purpose: Look at pipeline data to find patterns in deals you win vs. deals you lose. Pure computation + LLM reasoning.

Process

A) Win/Loss Pattern Analysis

B) Velocity Analysis

C) Activity-to-Outcome Correlation

Output Contract

deal_patterns: {
  win_profile: {
    best_source: string
    best_persona: string
    best_industry: string
    best_company_size: string
    avg_winning_cycle_days: float
    avg_touches_to_close: float
    common_traits: string[]
  }

  loss_profile: {
    top_loss_reason: string
    loss_stage: string                # Where deals die most
    common_loss_traits: string[]
    recoverable_losses: string        # "X% of lost deals were timing — could be re-engaged"
  }

  velocity: {
    bottleneck_stage: string
    kill_zone_stage: string
    sweet_spot: string                # Description of your easiest wins
  }

  activity_correlations: [
    { activity: string, correlation: "positive" | "negative" | "none", insight: string }
  ]

  deal_skill_grade: "A" | "B" | "C" | "D" | "F"
  deal_skill_summary: string
}

Step 5: Build Skill Assessment & Coaching Plan

Purpose: Synthesize email, call, and deal analysis into a personal sales skill assessment and a specific coaching plan. Pure LLM reasoning.

Input Contract

email_patterns: { ... }              # From Step 2
call_patterns: { ... } | null        # From Step 3 (if calls available)
deal_patterns: { ... }               # From Step 4
user_role: string                    # From config
experience_level: string             # From config
product_description: string          # From config
self_assessed_weakness: string       # From config

Skill Assessment Framework

Assess the user across sales skill dimensions relevant to their role:

SDR Skill Dimensions

AE Skill Dimensions

Founder Skill Dimensions

All SDR + AE dimensions, plus:

Scoring

For each dimension, assign a grade:

Coaching Plan

For each dimension graded C or below, produce:

Skill: [dimension name]
Current grade: [grade]
Evidence: [specific data points that drive the grade]
Root cause: [why this is happening — not just what, but why]

Coaching recommendation:
1. [Specific, actionable thing to do differently]
2. [Exercise or practice to build this skill]
3. [Example from their own data of when they did this well vs. poorly]

Model to follow:
[Pull from their own top-performing emails/calls as examples.
"Your email in Campaign X did this perfectly — replicate that approach."]

Measurable goal:
[Specific metric to track improvement. E.g., "Increase question count per
discovery call from 6 to 12 over the next 30 days."]

Personalized Playbook

Distill the user's winning patterns into a personal playbook:

## Your Winning Formula

Based on analyzing [X emails, Y calls, Z deals], here's what works for YOU:

### Your Best Email Pattern
Subject line style: [pattern]
Opening approach: [pattern]
Proof point that resonates: [specific proof]
CTA that converts: [specific CTA]
Ideal length: [word count]
Best framework: [framework]

Template (built from your own top performers):
> [Reconstructed template from their best emails]

### Your Best Call Pattern (if calls available)
Discovery approach: [how you open well]
Strongest questions: [questions that work for you]
Objection handle that works: [specific handle]
Demo style that converts: [approach]
Close technique: [how you get next steps]

### Your Win Profile
You close best when:
- The prospect is [title/seniority]
- The company is [size/industry]
- The deal came from [source]
- The cycle is [length]
- You [specific behavior that correlates with winning]

Output Contract

skill_assessment: {
  overall_grade: "A" | "B" | "C" | "D" | "F"
  overall_summary: string

  dimensions: [
    {
      name: string
      grade: string
      evidence: string[]
      strength_or_weakness: "strength" | "neutral" | "weakness"
    }
  ]

  top_strengths: [
    { skill: string, evidence: string, advice: string }  # "Keep doing this"
  ]

  top_weaknesses: [
    {
      skill: string
      grade: string
      evidence: string[]
      root_cause: string
      coaching: string[]
      model_from_own_data: string | null
      measurable_goal: string
    }
  ]

  personalized_playbook: {
    best_email_pattern: { ... }
    best_call_pattern: { ... } | null
    win_profile: string
    template_from_top_performers: string
  }

  self_assessment_validation: {
    user_said: string                 # Their self-assessed weakness
    data_says: string                 # What the data actually shows
    aligned: boolean                  # Do they match?
    surprise_finding: string | null   # Something they didn't know about themselves
  }
}

Step 6: Generate Coaching Report

Purpose: Produce the final coaching report — personal, actionable, and encouraging. Not a performance review. A coaching session.

Report Structure

# Sales Coaching Report — [User Name]
**Based on:** [X emails, Y calls, Z deals] over [analysis window]
**Role:** [SDR/AE/Founder]
**Product:** [what they sell]

---

## Your Sales Scorecard

| Skill | Grade | Trend | Notes |
|-------|-------|-------|-------|
| [skill 1] | [grade] | [improving/stable/declining] | [one-line note] |
| [skill 2] | [grade] | [trend] | [note] |
| ... |

**Overall:** [grade] — [one-sentence summary]

---

## What You're Great At

Your data shows clear strengths in these areas. Keep doing these things.

### 1. [Strength #1]
**Evidence:** [specific data — "Your Signal-Proof-Ask emails generate 2.3x the reply rate of your other emails"]
**Why it works:** [brief explanation]
**Advice:** [How to lean into this strength even more]

### 2. [Strength #2]
**Evidence:** [data]
**Why it works:** [explanation]

### 3. [Strength #3]
...

---

## Where to Improve

These are your highest-impact coaching areas. Focus on one at a time.

### Priority 1: [Biggest Weakness]
**Current grade:** [grade]
**Evidence:** [specific data points — not vague criticism, specific examples]
**Root cause:** [Why this is happening. E.g., "You're asking 4 questions per discovery call. The calls
where you asked 10+ had a 3x higher progression rate. You're not going deep enough on pain."]

**What to do differently:**
1. [Specific, actionable change]
2. [Practice exercise]
3. [Example from their own data: "In your call with [prospect] on [date], you DID do this well — here's the transcript excerpt. Replicate that approach."]

**Your own proof it works:**
> [Quote from their own top-performing email or call where they did this well]

**Goal:** [Measurable goal with timeframe]

### Priority 2: [Second Weakness]
[Same structure]

### Priority 3: [Third Weakness]
[Same structure]

---

## Your Winning Patterns (Personal Playbook)

These patterns come from YOUR best work — not a textbook.

### Your Best Email Template
[Reconstructed from their top-performing emails]

**Subject:** [pattern]
> [Reconstructed body using their winning patterns]

**Why this works for you:** [pattern analysis]

### Your Best Discovery Approach (if calls available)
[Distilled from their winning calls]

1. **Open with:** [how they open their best calls]
2. **Key questions to always ask:** [their best questions]
3. **When you hear [objection], say:** [their best objection handle]
4. **Close the call with:** [how they get next steps in winning calls]

### Your Win Profile
**You close best when:**
- Prospect is [title] at a [size] [industry] company
- Deal came from [source/channel]
- Cycle is [X] days
- You [specific winning behavior]

**You struggle when:**
- Prospect is [profile]
- Deal involves [situation]
- You [specific losing behavior]

---

## Surprise Finding

[Something the data reveals that the user probably doesn't know about themselves.
E.g., "You think your weakness is closing, but your data shows your close rate is
above average. Your actual bottleneck is discovery — you're booking meetings that
aren't qualified. Improving qualification would have 3x more impact than working
on closing technique."]

---

## 30-Day Coaching Plan

| Week | Focus | Exercise | Measurable Target |
|------|-------|----------|-------------------|
| Week 1 | [skill] | [specific exercise] | [metric to hit] |
| Week 2 | [skill] | [exercise] | [metric] |
| Week 3 | [skill] | [exercise] | [metric] |
| Week 4 | Review + adjust | Re-run this analysis | Compare grades |

---

## Check Back In

Run this coaching analysis again in 30 days to measure improvement.
Track these specific metrics:
1. [Metric 1 — current: X, target: Y]
2. [Metric 2 — current: X, target: Y]
3. [Metric 3 — current: X, target: Y]

Tone Guidance

This is a coaching session, not a performance review.

Human Checkpoint

[Scorecard + top strengths + top weakness rendered]

---

Surprise finding: [the thing they didn't know]

Full coaching report includes:
- Detailed skill assessment across [X] dimensions
- Your winning email template (reconstructed from top performers)
- Your winning call pattern (if call data available)
- Your win profile (what deals you close best)
- 30-day coaching plan with weekly exercises
- Measurable goals to track improvement

View the full coaching report?

Execution Summary

Total human review time: ~15-20 minutes for coaching that would normally require an experienced sales manager reviewing weeks of activity.

Adapting to Data Availability

Minimum viable: At least one of: email data, call data, or pipeline data.

Tips

• Run monthly for continuous improvement. The coaching plan is designed in 30-day cycles. Re-run and compare grades.
• The "surprise finding" is often the most valuable part. People's self-assessment of their sales weaknesses is wrong ~60% of the time. The data reveals the real bottleneck.
• Top-performing email templates from your own data beat any template library. They've already been tested on your market with your product.
• If call data is available, prioritize call coaching. Calls have more surface area for improvement than emails, and call improvements have a higher ROI per fix.
• The personalized playbook should be saved and reused. It's a living document that evolves as the user's skills evolve.
• Share the coaching report with a manager or mentor. It provides the data for a structured 1:1 coaching conversation.
• Focus on ONE weakness at a time. The coaching plan prioritizes. Don't try to fix everything at once — that's how nothing gets fixed.