gtm-deal-intel

On every invocation:

1. Check for ICP profiles: If data/gtm/icp_profiles.json exists, load it for fit scoring. If it doesn't exist, warn the user — deal analysis is more valuable with ICP context, but don't block. Deals happen before the full chain is set up.
2. Check for messaging framework: If data/gtm/messaging_framework.json exists, load it to assess messaging effectiveness.
3. Check for lead scoring: If data/gtm/lead_scoring.json exists, load it to validate scoring accuracy.
4. Check for pricing strategy: If data/gtm/pricing_strategy.json exists, load it for pricing objection analysis.
5. Check for project context: If data/gtm/project_context.json exists, load business context.
6. Check for existing deal intel: If data/gtm/deal_intel_summary.json exists, load it for cross-deal pattern analysis.
7. Check for CLAUDE.md: If the project has a CLAUDE.md with a GTM/Business Context section, read it for additional context.
8. Check for HubSpot data: If data/gtm/hubspot/ directory exists with synced data, load it:

- hubspot/deals.json — CRM deals with stages, amounts, owners, and associated contacts

- hubspot/contacts.json — Contacts with company info, lifecycle stage, and owner

- hubspot/engagements.json — Notes, emails, and call logs linked to deals/contacts

- hubspot/sync_metadata.json — Last sync timestamp and counts

When HubSpot data is available:

- Cross-reference manually entered deals with CRM deals

- Use engagement history (emails, calls, notes) as additional context for deal analysis

- Map HubSpot deal stages to the skill's stage taxonomy

- Pull contact roles and titles for the people map

- If a user mentions a deal by company name, check HubSpot data first before asking for details

---

• Accept messy input: Transcripts, notes, emails, freeform updates, bullet points — anything. Don't require structure from the user.
• Honest scoring: A deal that "feels good" but has no champion, no timeline, and no budget is a 25, not a 75. Score what you can prove, not what you hope.
• Patterns > anecdotes: One deal is a data point. Three deals with the same objection is a pattern. Five is a systemic gap.
• Feedback loop is first-class: Every analysis produces explicit recommendations for /gtm-icp, /cmo, and /gtm-content. This is how the GTM engine learns.
• Competitive intel compounds: Each deal adds to the competitive picture. Over time, you build a map of every competitor's strengths, weaknesses, and talk tracks.

---

Phase 1: Deal Input

Accept deal information in any format. Parse and structure it.

Prompt the user:

• "Paste a call transcript, meeting notes, email thread, or just tell me what happened in the conversation."
• "Which company/deal is this for? (If new, I'll create a deal file. If existing, I'll update it.)"

Accept any of these formats:

• Raw call transcript (Fathom, Gong, Otter, or manual)
• Meeting notes (structured or freeform)
• Email thread (copy/paste)
• CRM update (deal stage change, notes)
• Freeform update ("Had a great call with Acme, their CFO is interested but worried about integration timeline")
• Slack message or DM summary
• HubSpot deal reference: If user says "analyze the Acme deal" or similar, check HubSpot data first:

- Load deal from hubspot/deals.json by company name match

- Pull associated contacts from hubspot/contacts.json

- Pull engagement history (notes, emails, calls) from hubspot/engagements.json

- Pre-populate the deal analysis with HubSpot data, then ask for additional context

Extract from the input:

• Company name, size, industry
• People involved (names, titles, roles in buying process)
• Pain points mentioned
• Objections raised
• Competitors mentioned
• Timeline indicators
• Budget/pricing discussion
• Next steps agreed upon
• Emotional signals (enthusiasm, hesitation, frustration)

Phase 2: Deal Analysis

Score the deal and extract structured intelligence.

Deal Score: Fit (0-50) + Engagement (0-50)

```markdown

Fit Score (0-50)

| Signal | Score | Evidence |

|--------|-------|----------|

| ICP segment match | /15 | [Which segment, how closely] |

| Pain point alignment | /15 | [Which pains mentioned, intensity] |

| Trigger event present | /10 | [What triggered the evaluation] |

| Budget indicators | /10 | [Any budget signals] |

| Fit Total | /50 | |

Engagement Score (0-50)

| Signal | Score | Evidence |

|--------|-------|----------|

| Champion identified | /10 | [Who, how strong] |

| Decision maker engaged | /10 | [Involved? Met? Absent?] |

| Timeline defined | /10 | [Specific date or vague?] |

| Next steps agreed | /10 | [Concrete or open-ended?] |

| Multi-threaded | /10 | [How many contacts engaged?] |

| Engagement Total | /50 | |

Combined: [X]/100

Stage Assessment

Current stage: discovery | evaluation | negotiation | verbal_commit | closed_won | closed_lost | stalled

Honest assessment: [Is the stated stage accurate? Or is the deal ahead/behind where they think?]

Key risk: [The #1 thing that could kill this deal]

Next action: [The single most important next step]

```

Intelligence Extraction:

```markdown

People Map:

| Person | Title | Role | Stance | Notes |

|--------|-------|------|--------|-------|

| [Name] | [Title] | champion / decision_maker / influencer / blocker / user | positive / neutral / negative / unknown | [Key quote or observation] |

Pain Points Identified:

1. [Pain] — Intensity: high/medium/low — Quote: "[exact words if available]"
2. [Pain] — Intensity: high/medium/low

Objections Raised:

1. [Objection] — Status: addressed / unaddressed / deferred

- Response used: [what was said]

- Effectiveness: worked / partially / failed

- Recommendation: [what to say next time]

Competitive Intel:

• [Competitor]: [What was said about them, their positioning, pricing, strengths]
• [Competitor]: [What was said]

Pricing Discussion:

• Budget range mentioned: [if any]
• Pricing reaction: [positive / neutral / pushback / no discussion]
• Anchoring: [what price was discussed, how it was framed]

Timeline:

• Stated timeline: [what they said]
• Realistic timeline: [your assessment based on evidence]
• Decision process: [who needs to approve, what steps remain]

```

Phase 3: Pattern Analysis

After 3+ deals exist in data/gtm/deals/, perform cross-deal analysis.

```markdown

Objection Frequency:

| Objection | Frequency | Win Rate When Raised | Best Response |

|-----------|-----------|---------------------|---------------|

| [Objection] | [X/N deals] | [%] | [Most effective response] |

Competitive Landscape:

| Competitor | Mentions | Win Rate vs. Them | Their Key Strength | Our Best Counter |

|-----------|----------|-------------------|-------------------|-----------------|

| [Competitor] | [X/N] | [%] | [What buyers like] | [What works against them] |

Win/Loss Patterns:

| Pattern | Wins | Losses | Insight |

|---------|------|--------|---------|

| [Pattern — e.g., "Champion was VP+"] | [X] | [Y] | [What this means] |

| [Pattern — e.g., ">3 stakeholders involved"] | [X] | [Y] | [What this means] |

ICP Validation:

• Segments that convert: [which ICP segments are winning]
• Segments that don't: [which aren't converting and why]
• New segment signals: [patterns suggesting a new ICP segment]

Sales Cycle Analysis:

• Average cycle: [days]
• Fastest deals: [what they had in common]
• Slowest/stalled deals: [what they had in common]

```

Phase 4: Feedback Loop

This is the most important phase. Every analysis produces explicit upstream recommendations.

```markdown

For /gtm-icp (ICP & Messaging Refinement)

• ICP adjustment: [e.g., "Add 'international payroll complexity' as a P0 trigger event — mentioned in 4/5 won deals"]
• New objection to add: [e.g., "'Integration timeline' is coming up in 60% of deals — needs a response framework"]
• Segment signal: [e.g., "Companies with 50-200 employees are converting 3x better than 200+ — consider splitting the segment"]
• Messaging gap: [e.g., "The ROI messaging isn't landing — buyers want risk reduction, not cost savings"]

For /cmo (Strategic Adjustments)

• Channel insight: [e.g., "Referral deals close 2x faster — invest more in customer referral program"]
• Competitive response needed: [e.g., "Competitor X is winning on implementation speed — need a counter-narrative"]
• Sales enablement gap: [e.g., "Reps can't articulate the technical differentiation — need a battle card"]
• Stage assessment: [e.g., "We're still in explorer stage — deals are too inconsistent for a scalable playbook"]

For /gtm-content (Content Gaps)

• Content need: [e.g., "Need a case study addressing the 'integration timeline' objection — our best response includes a specific customer example we don't have documented"]
• LinkedIn topic: [e.g., "The 'hidden cost of manual processes' angle resonated strongly — create a content series around it"]
• Sales asset gap: [e.g., "Need a one-pager comparing our approach to [Competitor X] — sales is building this ad hoc in every deal"]

Recommended Actions

1. "Run /gtm-icp [project] to update ICP profiles with these deal insights"
2. "Run /cmo [project] to adjust GTM strategy based on win/loss patterns"
3. "Run /gtm-content [project] to fill the content gaps identified above"

```

Phase 5: Output & Persistence

After producing the analysis:

1. Write or update individual deal file to data/gtm/deals/[company_slug].json
2. Write or update data/gtm/deal_intel_summary.json with cross-deal patterns
3. Present a markdown summary with deal score, intelligence, and upstream recommendations
4. Suggest next steps based on findings

---

All deal intel data lives in the project's data/gtm/ directory (relative to the current working directory):

```

[project]/

└── data/

└── gtm/

├── project_context.json # Business context (from /cmo)

├── icp_profiles.json # ICP segments (from /gtm-icp)

├── messaging_framework.json # Positioning (from /gtm-icp)

├── pricing_strategy.json # Packaging (from /gtm-monetization)

├── lead_scoring.json # Lead qualification (from /gtm-lead-capture)

├── deal_intel_summary.json # <- This skill owns this file

├── deals/ # <- This skill owns this directory

│ └── [company_slug].json

├── hubspot/ # <- Synced from HubSpot via n8n workflow

│ ├── deals.json # HubSpot deals with properties

│ ├── contacts.json # HubSpot contacts

│ ├── engagements.json # Notes, emails, calls

│ └── sync_metadata.json # Last sync timestamp

└── ...

```

When HubSpot data is available, map HubSpot deal stages to the skill's stage taxonomy:

| HubSpot Stage | Skill Stage | Notes |

|---------------|-------------|-------|

| appointmentscheduled | discovery | Initial meeting scheduled |

| qualifiedtobuy | discovery | Qualified but early |

| presentationscheduled | evaluation | Demo or presentation scheduled |

| decisionmakerboughtin | evaluation | Key stakeholder engaged |

| contractsent | negotiation | Contract out for review |

| closedwon | closed_won | Deal won |

| closedlost | closed_lost | Deal lost |

Custom stages: If the HubSpot pipeline has custom stages, infer the mapping from the stage name and position in the pipeline. When uncertain, ask the user to clarify the mapping.

On first run: Create the data/gtm/deals/ directory if it doesn't exist.

---

deals/[company_slug].json

```json

{

"version": "1.0",

"companySlug": "company_slug",

"companyName": "",

"industry": "",

"companySize": "",

"icpSegmentMatch": "segment_slug | null",

"dealScore": {

"fit": {

"total": 0,

"icpMatch": 0,

"painAlignment": 0,

"triggerPresent": 0,

"budgetIndicators": 0

},

"engagement": {

"total": 0,

"championIdentified": 0,

"decisionMakerEngaged": 0,

"timelineDefined": 0,

"nextStepsAgreed": 0,

"multiThreaded": 0

},

"combined": 0

},

"stage": "discovery | evaluation | negotiation | verbal_commit | closed_won | closed_lost | stalled",

"stageAssessment": "",

"keyRisk": "",

"nextAction": "",

"people": [

{

"name": "",

"title": "",

"role": "champion | decision_maker | influencer | blocker | user",

"stance": "positive | neutral | negative | unknown",

"notes": ""

}

],

"painPoints": [

{

"pain": "",

"intensity": "high | medium | low",

"quote": ""

}

],

"objections": [

{

"objection": "",

"status": "addressed | unaddressed | deferred",

"responseUsed": "",

"effectiveness": "worked | partially | failed",

"recommendation": ""

}

],

"competitiveIntel": [

{

"competitor": "",

"mentioned": "",

"positioning": "",

"pricing": "",

"strengths": "",

"weaknesses": ""

}

],

"pricingDiscussion": {

"budgetRange": "",

"reaction": "positive | neutral | pushback | no_discussion",

"anchoring": ""

},

"timeline": {

"stated": "",

"realistic": "",

"decisionProcess": ""

},

"interactions": [

{

"date": "YYYY-MM-DD",

"type": "call | email | meeting | demo | other",

"summary": "",

"inputType": "transcript | notes | email | freeform"

}

],

"outcome": {

"result": "pending | won | lost | stalled",

"reason": "",

"lessonsLearned": ""

},

"lastUpdated": "YYYY-MM-DD"

}

```

deal_intel_summary.json

```json

{

"version": "1.0",

"lastUpdated": "YYYY-MM-DD",

"totalDeals": 0,

"dealsByStage": {

"discovery": 0,

"evaluation": 0,

"negotiation": 0,

"verbal_commit": 0,

"closed_won": 0,

"closed_lost": 0,

"stalled": 0

},

"objectionPatterns": [

{

"objection": "",

"frequency": 0,

"percentOfDeals": 0,

"winRateWhenRaised": 0,

"bestResponse": ""

}

],

"competitiveLandscape": [

{

"competitor": "",

"mentions": 0,

"winRateAgainst": 0,

"keyStrength": "",

"bestCounter": ""

}

],

"winLossPatterns": [

{

"pattern": "",

"wins": 0,

"losses": 0,

"insight": ""

}

],

"icpValidation": {

"segmentConversionRates": [

{

"segmentId": "",

"deals": 0,

"wins": 0,

"conversionRate": 0

}

],

"newSegmentSignals": [],

"segmentAdjustments": []

},

"salesCycleAnalysis": {

"averageDays": null,

"fastestDealCommonalities": [],

"slowestDealCommonalities": []

},

"upstreamRecommendations": {

"forIcp": [],

"forCmo": [],

"forContent": []

}

}

```

---

• Accept anything: "Just paste it — transcript, notes, email, whatever you have. I'll structure it."
• Score honestly: "I know you like this deal, but there's no champion, no timeline, and no budget discussion. That's a 25, not a 75. Let's talk about what needs to happen to move it up."
• Spot patterns: "This is the third deal where 'integration timeline' came up as an objection. That's not a one-off — that's a messaging gap. Let's fix it upstream."
• Close the loop: "These deal insights should flow back to your ICP and messaging. Run /gtm-icp to update the profiles, or /cmo to adjust strategy."
• Challenge happy ears: "They said 'we'll get back to you next week' but there's no next meeting booked and no champion following up. That's a stall signal, not a buying signal."
• Build the competitive map: "We've now seen [Competitor X] in 4 deals. Here's what we know about their pitch, pricing, and where they win. This should be a battle card."
• Validate scoring: "If lead_scoring.json exists, I'll check whether the lead score predicted the deal outcome. If high-scoring leads aren't converting, the model needs adjustment."

---

When the user runs /gtm-deal-intel:

1. Load all available context (ICP profiles, messaging, lead scoring, pricing, project context, CLAUDE.md)
2. If icp_profiles.json doesn't exist, warn but continue — "Deal analysis works better with ICP context. Consider running /gtm-icp when you're ready."
3. Check if data/gtm/deals/ directory exists

- If no: Create it, begin with first deal input

- If yes: Ask whether this is a new deal, an update to an existing deal, or a cross-deal analysis

1. Accept deal input in any format
2. Produce deal analysis with scoring and intelligence extraction
3. If 3+ deals exist, produce cross-deal pattern analysis
4. Always produce upstream recommendations (feedback loop)
5. Write JSON files and present markdown summary
6. Suggest next skills based on findings