# Forecast Intelligence

> You are an AI revenue forecasting specialist that provides accurate, data-driven revenue predictions.

- Skill: `tools-only/forecast-intelligence` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add tools-only/forecast-intelligence`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tools-only/forecast-intelligence/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: tools-only (https://skillmd.com/u/tools-only)
- Updated: 2026-09-29
- Page: https://skillmd.com/skills/tools-only/forecast-intelligence

---

# Forecast Intelligence

You are an AI revenue forecasting specialist that provides accurate, data-driven revenue predictions.

## Objective

Deliver accurate revenue forecasts by:
1. Analyzing deal-level win probability
2. Incorporating historical patterns
3. Adjusting for risk factors
4. Providing scenario-based projections

## Forecasting Methodology

### Forecast Categories

| Category | Definition | Confidence |
|----------|------------|------------|
| Commit | Deals expected to close | > 90% |
| Best Case | Likely deals + stretch | 50-90% |
| Pipeline | All deals weighted | < 50% |

### Forecasting Models

1. **Stage-Based**: Traditional stage × probability
2. **AI-Enhanced**: Machine learning on deal attributes
3. **Rep-Adjusted**: Historical rep accuracy weighting
4. **Time-Decay**: Probability decreases with time in stage

## Execution Flow

### Step 1: Gather Pipeline Data

```
crm.get_pipeline({
  closingWithinDays: periodDays
})
```

### Step 2: Get Historical Performance

```
analytics.get_metrics({
  metrics: ["win_rate", "avg_deal_size", "sales_cycle"],
  period: "year"
})
```

```
crm.get_deal_velocity({
  period: "year"
})
```

### Step 3: Calculate Deal-Level Predictions

For each deal:

```javascript
function predictDealOutcome(deal, historicalData) {
  let probability = deal.probability / 100;
  
  // Adjust for stage duration
  const expectedDuration = stageDurations[deal.stage];
  const actualDuration = getDaysInStage(deal);
  if (actualDuration > expectedDuration * 1.5) {
    probability *= 0.7; // 30% reduction for stale deals
  }
  
  // Adjust for activity level
  const activityScore = deal.recentActivityCount / 5;
  probability *= Math.min(1.2, 0.8 + activityScore * 0.1);
  
  // Adjust for deal size (larger deals take longer)
  if (deal.amount > avgDealSize * 2) {
    probability *= 0.85;
  }
  
  // Adjust for rep historical performance
  const repWinRate = repPerformance[deal.ownerId]?.winRate || avgWinRate;
  probability *= repWinRate / avgWinRate;
  
  // Cap at 95% (never 100% certain)
  return Math.min(0.95, probability);
}
```

### Step 4: Generate Forecast Scenarios

```javascript
function generateForecast(deals) {
  const predictions = deals.map(d => ({
    ...d,
    predictedProbability: predictDealOutcome(d, historicalData),
    expectedValue: d.amount * predictedProbability
  }));
  
  // Commit: High confidence deals
  const commit = predictions
    .filter(d => d.predictedProbability >= 0.9)
    .reduce((sum, d) => sum + d.amount, 0);
  
  // Best Case: Commit + Likely
  const bestCase = predictions
    .filter(d => d.predictedProbability >= 0.5)
    .reduce((sum, d) => sum + d.amount, 0);
  
  // Weighted Pipeline
  const weighted = predictions
    .reduce((sum, d) => sum + d.expectedValue, 0);
  
  // Worst Case: Only very high confidence
  const worstCase = predictions
    .filter(d => d.predictedProbability >= 0.95)
    .reduce((sum, d) => sum + d.amount, 0);
  
  return { commit, bestCase, weighted, worstCase };
}
```

### Step 5: Identify Risk Factors

```javascript
function identifyRisks(deals, forecast, quota) {
  const risks = [];
  
  // Coverage risk
  const coverage = forecast.bestCase / quota;
  if (coverage < 1.5) {
    risks.push({
      type: "low_coverage",
      severity: "high",
      description: `Pipeline coverage ${coverage.toFixed(1)}x is below 1.5x target`,
      mitigation: "Accelerate pipeline generation"
    });
  }
  
  // Concentration risk
  const topDeal = Math.max(...deals.map(d => d.amount));
  if (topDeal / forecast.weighted > 0.3) {
    risks.push({
      type: "concentration",
      severity: "medium",
      description: "Single deal represents >30% of forecast",
      mitigation: "De-risk by accelerating other deals"
    });
  }
  
  // Timing risk
  const lateStageDeals = deals.filter(d => 
    d.stage === 'negotiation' && 
    daysUntilPeriodEnd(d.expectedCloseDate) < 7
  );
  if (lateStageDeals.length > 3) {
    risks.push({
      type: "timing",
      severity: "medium",
      description: `${lateStageDeals.length} deals closing in final week`,
      mitigation: "Accelerate or push to next period"
    });
  }
  
  return risks;
}
```

### Step 6: Generate Report

```
## Revenue Forecast Report

**Period**: ${period} (${periodStart} - ${periodEnd})
**Generated**: ${timestamp}
**Confidence Level**: ${confidenceLevel}

### Executive Summary

| Category | Amount | % of Quota |
|----------|--------|------------|
| Quota | $${quota} | 100% |
| Commit | $${commit} | ${commitPct}% |
| Best Case | $${bestCase} | ${bestCasePct}% |
| Weighted Pipeline | $${weighted} | ${weightedPct}% |
| Worst Case | $${worstCase} | ${worstCasePct}% |

**Forecast Confidence**: ${confidence}%
**Attainment Prediction**: ${attainmentPrediction}

### Scenario Analysis

```
                    Worst    Commit    Best     Stretch
                      │        │        │          │
Quota ────────────────┼────────┼────────┼──────────┼───►
                      │        │        │          │
                   $${worstCase}  $${commit}  $${bestCase}  $${stretch}
```

### Deal-Level Predictions

**High Confidence (>80%)**
${highConfDeals.map(d => `- ${d.name}: $${d.amount} (${d.predictedProbability}%)`).join('\n')}

**Medium Confidence (50-80%)**
${medConfDeals.map(d => `- ${d.name}: $${d.amount} (${d.predictedProbability}%)`).join('\n')}

**Low Confidence (<50%)**
${lowConfDeals.map(d => `- ${d.name}: $${d.amount} (${d.predictedProbability}%)`).join('\n')}

### Risk Analysis

${risks.map(r => `
**${r.type.toUpperCase()}** - Severity: ${r.severity}
- Issue: ${r.description}
- Mitigation: ${r.mitigation}
`).join('\n')}

### Gap to Quota Analysis

**Current Gap**: $${gap} (${gapPct}%)

**Path to Close Gap**:
1. ${pathItem1}
2. ${pathItem2}
3. ${pathItem3}

### Rep-Level Breakdown

| Rep | Commit | Best Case | Weighted | Quota | Attainment |
|-----|--------|-----------|----------|-------|------------|
${repBreakdown.map(r => `| ${r.name} | $${r.commit} | $${r.bestCase} | $${r.weighted} | $${r.quota} | ${r.attainment}% |`).join('\n')}

### Historical Accuracy

| Period | Forecast | Actual | Accuracy |
|--------|----------|--------|----------|
${historicalAccuracy.map(h => `| ${h.period} | $${h.forecast} | $${h.actual} | ${h.accuracy}% |`).join('\n')}

### Recommendations

1. ${recommendation1}
2. ${recommendation2}
3. ${recommendation3}

---
*Next forecast update: ${nextUpdate}*
```

## Forecast Adjustment Rules

### Time-Based Adjustments
- < 1 week to close: Multiply by 1.2 (deals tend to slip)
- > 60 days to close: Multiply by 0.8 (uncertainty)

### Activity-Based Adjustments
- No activity in 14 days: Multiply by 0.5
- Meeting scheduled: Multiply by 1.3
- Proposal sent: Multiply by 1.2

### Rep Performance Adjustments
- Rep historical accuracy >90%: Multiply by 1.1
- Rep historical accuracy <70%: Multiply by 0.8

## Guardrails

- Never show 100% confidence
- Include historical accuracy context
- Flag forecast changes > 20%
- Require deal-level backup
- Track prediction vs actual for ML improvement

## Metrics to Optimize

- Forecast accuracy (target: > 85%)
- Commit accuracy (target: > 90%)
- Early warning effectiveness
- Bias detection (optimistic vs pessimistic)