references/qbr_framework.md
# QBR Framework Reference
## QBR Outline Template
Every QBR follows this structure — no exceptions:
```
1. EXECUTIVE SUMMARY (1 paragraph, C-level language)
2. QUARTER SCORECARD (6 dimensions, color-coded)
3. PLAN VS ACTUAL (every KPI: planned → actual → gap → explanation)
4. BUSINESS PERFORMANCE (revenue, leads, sales, market share)
5. MEDIA REVIEW (efficiency, delivery, allocation, waste)
6. CRM / LIFECYCLE REVIEW (journey performance, engagement, retention)
7. CREATIVE & CONTENT REVIEW (performance, fatigue, production)
8. OPERATIONAL REVIEW (SLA, timeline, blockers, QA, team)
9. FINANCIAL REVIEW (budget pacing, margin, scope compliance)
10. SCOPE & CHANGE ORDERS (what changed vs original SOW)
11. MEASUREMENT CONFIDENCE (what can / cannot be claimed)
12. LEARNINGS (what worked, what didn't, key insights)
13. NEXT QUARTER PRIORITIES (ranked by Impact × Readiness × Urgency)
14. DECISIONS NEEDED (explicit asks for leadership)
```
## Plan vs Actual Framework
### The comparison rule
Every QBR must compare **what was planned** against **what was delivered**. Without this comparison, the QBR is just a report — not a review.
### Status classification
| Gap vs plan | Status | Color | Action required |
|------------|--------|-------|-----------------|
| ≥ +5% | Exceeded | Green | Investigate success drivers for replication |
| -5% to +5% | On track | Green | Continue current approach |
| -5% to -15% | Behind | Amber | Corrective action in progress or planned |
| < -15% | Missed | Red | Root cause required + recovery plan |
### What to compare
| Area | Plan source | Actual source |
|------|------------|---------------|
| Business KPIs | SOW targets, brief objectives | CRM, sales data, GA4 |
| Media delivery | Media plan from `media-routing-planner` | Platform reports, Supermetrics |
| CRM performance | Journey targets from `crm-journey-architect` | SFMC/AJO reports |
| Creative production | Asset matrix from `creative-supply-planner` | Production tracker |
| Budget | SOW budget, media plan | Finance, platform spend |
| Timeline | Project plan | Delivery log |
| SLA | SOW SLA commitments | Operational tracking |
## Executive Scorecard Framework
### 6 dimensions, weighted
| Dimension | Weight | What it measures | Data sources |
|-----------|--------|-----------------|-------------|
| Business performance | 25% | Revenue, leads, sales vs targets | CRM, sales, GA4 |
| Media efficiency | 20% | ROAS, CPA, reach, frequency vs plan | Platform reports |
| CRM / lifecycle | 15% | Journey CVR, email metrics, retention | SFMC/AJO |
| Creative & content | 10% | Creative performance, fatigue, delivery | Creative tracker |
| Operational delivery | 15% | SLA, timeline, blockers, QA | PM tracker |
| Financial health | 15% | Budget pacing, margin, scope compliance | Finance |
### Scoring guide
| Score range | Status | What it means |
|------------|--------|---------------|
| 80-100 | Strong | Exceeding expectations — document what's working |
| 60-79 | On track | Meeting expectations — maintain approach |
| 40-59 | At risk | Below expectations — corrective action needed |
| 0-39 | Critical | Significantly underperforming — escalation required |
### Overall score interpretation
| Overall | Quarter verdict | Recommended framing |
|---------|----------------|-------------------|
| ≥ 80 | Strong quarter | Lead with wins, propose growth investment |
| 60-79 | Solid quarter | Balanced narrative, highlight optimization opportunities |
| 40-59 | Mixed quarter | Lead with learnings, present recovery plan |
| < 40 | Difficult quarter | Lead with root cause analysis, present restructuring plan |
## Upstream Context Mapping
The QBR synthesizes outputs from ALL upstream skills:
| Skill | What it feeds into the QBR |
|-------|---------------------------|
| `weekly-control-tower` | 12-13 weeks of health scores, anomalies, KPI trends |
| `margin-simulation` | Margin %, leakage, P&L impact |
| `scope-audit` | Scope compliance, hidden scope, CO triggers |
| `fte-capacity-sizing` | Utilization, AI automation rate, capacity gaps |
| `change-order-generator` | COs issued, value, approval status |
| `campaign-launch-qa` | Launch readiness, QA pass rates |
| `media-routing-planner` | Allocation vs plan, optimization recommendations |
| `media-procurement-benchmark` | Rate competitiveness, leakage |
| `crm-journey-architect` | Journey completion, CRM KPIs |
| `audience-segmentation-brief` | Segment performance, CLV trends |
| `creative-supply-planner` | Production delivery, fatigue schedule |
| `measurement-incrementality` | Evidence level, iROAS vs reported ROAS |
| `performance-diagnosis` | Root causes, corrective actions |
| `executive-growth-memo` | Weekly executive summaries (13 weeks = QBR input) |
## Mandatory Benchmark Search Protocol
**BEFORE building the QBR, search for quarterly context:**
1. `"[INDUSTRY] [COUNTRY] market trends Q[N] [YEAR]"` — macro context
2. `"Kantar Worldpanel [CATEGORY] [COUNTRY] Q[N]"` — category performance
3. `"[PLATFORM] advertising benchmarks [INDUSTRY] [YEAR]"` — media benchmarks
4. `"email marketing benchmarks [INDUSTRY] [YEAR]"` — CRM context
5. `"Nielsen ad intel [INDUSTRY] [COUNTRY] Q[N]"` — competitive SOV context
references/quarterly_planning.md
# Quarterly Planning & Learning Reference
## Learning Extraction Framework
### How to extract learnings from a quarter
Every learning must follow this format:
```
OBSERVATION: [What happened — data point]
INSIGHT: [Why it happened — analysis]
IMPLICATION: [What it means for next quarter — action]
```
### Learning categories
| Category | Examples | How to extract |
|----------|---------|----------------|
| **Channel efficiency** | "TikTok outperformed Meta on CPA by 35%" | Compare ROAS/CPA across channels, control for spend level |
| **Audience behavior** | "Returning customers converted 3× vs new" | Segment performance by audience type |
| **Creative performance** | "UGC video outperformed studio by 2×" | Compare creative formats/styles at equal spend |
| **CRM effectiveness** | "Welcome series drove 12% incremental reactivation" | Measure journey impact with holdout or pre/post |
| **Funnel bottleneck** | "Bounce rate on LP killed 40% of paid traffic" | Funnel gap analysis (performance-diagnosis skill) |
| **Operational** | "Approval delays pushed launch back 2 weeks" | Timeline compliance analysis |
| **Market/competitive** | "Competitor launched during our flight, CPC +25%" | Competitive monitoring + CPM/CPC trend correlation |
| **Measurement** | "Platform ROAS overstated by 2.5× vs holdout test" | Compare platform-reported vs incrementality test results |
### Anti-patterns (bad learnings)
| Bad learning | Why it's bad | Better version |
|-------------|-------------|----------------|
| "CTR was 2.1%" | No context — is that good or bad? | "CTR at 2.1% exceeded industry benchmark of 1.8% (+17%)" |
| "Campaign performed well" | No specifics | "Campaign exceeded CPA target by 12% on $X spend" |
| "We need better creative" | No evidence | "CTR declined 30% over 4 weeks at 6× frequency — creative fatigue detected" |
| "The market was tough" | Unactionable excuse | "Category demand declined 8% (Kantar) — our share held at X%, suggesting media maintained position" |
## Next-Quarter Prioritization
### Priority scoring: Impact × Readiness × Urgency
| Dimension | Score 1-10 | What it measures |
|-----------|-----------|-----------------|
| **Impact** | How much will this move the business? | 10 = directly increases revenue/reduces cost; 1 = nice-to-have |
| **Readiness** | Can we execute this next quarter? | 10 = ready to go; 1 = needs months of prep |
| **Urgency** | What happens if we wait? | 10 = competitive disadvantage or missed window; 1 = can wait |
### Priority score = Impact × Readiness × Urgency / 10
| Score range | Priority tier | Action |
|------------|--------------|--------|
| ≥ 50 | Must-do | Include in Q+1 plan, assign owner, set deadline |
| 30-49 | Should-do | Plan if capacity allows, build business case |
| 15-29 | Could-do | Backlog for Q+2, prep requirements |
| < 15 | Deprioritize | Not worth the investment this cycle |
### Standard next-quarter priorities to consider
| Priority | When to recommend |
|----------|------------------|
| Incrementality test | No causal measurement exists; need to validate platform ROAS |
| Creative refresh | Fatigue detected; rotation schedule shows gap |
| Channel expansion | Current channels saturated; untapped channels available |
| CRM journey optimization | Journey completion < 40% or CRM CVR below benchmark |
| Audience expansion | Core audiences saturated; new segments available |
| Measurement upgrade | Still at attribution level; need to move to incrementality |
| Scope restructuring | Margin erosion, scope drift, or commercial misalignment |
| Budget reallocation | Significant ROAS variance across channels |
| Technology upgrade | Platform limitations blocking optimization |
| Team/process restructuring | Operational bottlenecks impacting delivery |
## QBR-to-Action Bridge
### How the QBR connects to next-quarter execution
```
QBR Output → Triggers these OS skills next quarter:
Scorecard "at risk" dimensions:
→ performance-diagnosis (root cause)
→ corrective-action (recovery plan)
Missed KPIs:
→ media-routing-planner (re-optimize allocation)
→ creative-supply-planner (refresh plan)
Scope drift detected:
→ scope-audit (validate new scope)
→ change-order-generator (price the delta)
→ margin-simulation (validate profitability)
Measurement gap:
→ measurement-incrementality (design test)
→ mmm-modeling (if 2+ years data available)
CRM underperformance:
→ crm-journey-architect (redesign journey)
→ audience-segmentation-brief (refine segments)
Budget defense needed:
→ executive-growth-memo (prepare CFO narrative)
→ measurement-incrementality (prove impact)
```
Every QBR ends with explicit skill chain recommendations — the next quarter's OS execution plan.
## File Generation Guidelines
When the user requests a QBR deliverable:
- **PPTX deck**: Use the `pptx` skill to generate an executive slide deck
- **Excel scorecard**: Use the `xlsx` skill for the interactive scorecard with charts
- **Word document**: Use the `docx` skill for a formal narrative QBR report
- **Inline artifact**: Always produce the visual scorecard + plan vs actual as inline HTML widgets
Claude should ask the user which format(s) they want, or default to inline artifact + PPTX.
scripts/qbr_builder.py
#!/usr/bin/env python3
"""
QBR Builder
============
Consolidated QBR engine: Plan vs Actual comparison, KPI gap analysis,
executive scorecard scoring, learning extraction, and next-quarter
priority ranking.
From the stack: Executive layer → narrative generation support +
Governance → risk scoring (scorecard dimensions).
Not ML — it's structured comparison (plan vs actual) + weighted scoring
(scorecard dimensions) + priority ranking (Impact × Readiness × Urgency).
Usage:
from scripts.qbr_builder import QBRBuilder
builder = QBRBuilder(config)
result = builder.build()
"""
import json
import sys
import argparse
from dataclasses import dataclass, field, asdict
from datetime import datetime
# ── Scorecard Dimensions ────────────────────────────────────────────────────
SCORECARD_DIMENSIONS = {
"business_performance": {"label": "Business performance", "weight": 25,
"description": "Revenue, leads, sales vs targets"},
"media_efficiency": {"label": "Media efficiency", "weight": 20,
"description": "ROAS, CPA, reach, frequency vs plan"},
"crm_lifecycle": {"label": "CRM / lifecycle", "weight": 15,
"description": "Journey performance, email metrics, retention"},
"creative_content": {"label": "Creative & content", "weight": 10,
"description": "Creative performance, fatigue, production delivery"},
"operational_delivery": {"label": "Operational delivery", "weight": 15,
"description": "SLA compliance, timeline, blockers, QA"},
"financial_health": {"label": "Financial health", "weight": 15,
"description": "Budget pacing, margin, scope compliance"},
}
@dataclass
class PlanVsActualItem:
area: str
metric: str
planned: float
actual: float
gap: float
gap_pct: float
status: str # on_track, behind, ahead, missed, exceeded
explanation: str = ""
@dataclass
class DimensionScore:
dimension: str
label: str
weight: int
score: float # 0-100
status: str # strong, on_track, at_risk, critical
evidence: list = field(default_factory=list)
business_implication: str = ""
@dataclass
class NextPriority:
priority: str
why_it_matters: str
required_action: str
owner: str
impact_score: int # 1-10
readiness_score: int # 1-10
urgency_score: int # 1-10
priority_score: float # Impact × Readiness × Urgency / 10
@dataclass
class QBRResult:
client_name: str = ""
quarter: str = ""
date: str = ""
# Scorecard
overall_score: float = 0
overall_status: str = ""
dimension_scores: list = field(default_factory=list)
# Plan vs Actual
plan_vs_actual: list = field(default_factory=list)
total_kpis: int = 0
kpis_on_track: int = 0
kpis_behind: int = 0
# Learnings
what_worked: list = field(default_factory=list)
what_didnt: list = field(default_factory=list)
key_learnings: list = field(default_factory=list)
# Next quarter
priorities: list = field(default_factory=list)
decisions_needed: list = field(default_factory=list)
# Scope / change
change_orders: list = field(default_factory=list)
scope_drift_items: list = field(default_factory=list)
# Measurement confidence
measurement_confidence: str = ""
measurement_caveats: list = field(default_factory=list)
def to_dict(self):
def rf(obj, d=2):
if isinstance(obj, float): return round(obj, d)
elif isinstance(obj, dict): return {k: rf(v, d) for k, v in obj.items()}
elif isinstance(obj, list): return [rf(i, d) for i in obj]
return obj
return rf(asdict(self))
def to_json(self, indent=2):
return json.dumps(self.to_dict(), indent=indent, ensure_ascii=False)
class QBRBuilder:
"""
Config keys:
client_name, quarter (e.g., "Q3 2026"),
# Plan vs Actual
kpis: list[{area, metric, planned, actual, explanation}]
# Dimension inputs (for scorecard)
dimension_inputs: {
business_performance: {score: 0-100, evidence: [], implication: ""},
media_efficiency: {...}, crm_lifecycle: {...},
creative_content: {...}, operational_delivery: {...},
financial_health: {...}
}
# Learnings
what_worked: list[str]
what_didnt: list[str]
# Next quarter
proposed_priorities: list[{priority, why, action, owner, impact, readiness, urgency}]
decisions_needed: list[str]
# Scope
change_orders: list[{description, value, status}]
scope_drift: list[str]
# Measurement
measurement_level: str — delivery, attribution, correlation, incrementality
measurement_caveats: list[str]
"""
def __init__(self, config: dict):
self.config = config
self.result = QBRResult(
client_name=config.get("client_name", ""),
quarter=config.get("quarter", ""),
date=datetime.now().strftime("%Y-%m-%d"),
)
def build(self) -> QBRResult:
self._build_plan_vs_actual()
self._build_scorecard()
self._build_learnings()
self._build_priorities()
self._build_scope_review()
self._build_measurement()
return self.result
def _build_plan_vs_actual(self):
kpis = self.config.get("kpis", [])
on_track = 0
behind = 0
for kpi in kpis:
planned = kpi.get("planned", 0)
actual = kpi.get("actual", 0)
gap = actual - planned
gap_pct = (gap / planned * 100) if planned > 0 else 0
if gap_pct >= 5:
status = "exceeded"
elif gap_pct >= -5:
status = "on_track"
elif gap_pct >= -15:
status = "behind"
else:
status = "missed"
if status in ("on_track", "exceeded"):
on_track += 1
else:
behind += 1
self.result.plan_vs_actual.append(asdict(PlanVsActualItem(
area=kpi.get("area", ""),
metric=kpi.get("metric", ""),
planned=planned, actual=actual,
gap=round(gap, 2), gap_pct=round(gap_pct, 1),
status=status,
explanation=kpi.get("explanation", ""),
)))
self.result.total_kpis = len(kpis)
self.result.kpis_on_track = on_track
self.result.kpis_behind = behind
def _build_scorecard(self):
dim_inputs = self.config.get("dimension_inputs", {})
total_weight = 0
weighted_sum = 0
for dim_key, dim_info in SCORECARD_DIMENSIONS.items():
user_input = dim_inputs.get(dim_key, {})
score = user_input.get("score", 50) # Default: neutral
# Auto-adjust from plan_vs_actual if dimensions not provided
if dim_key == "business_performance" and not user_input.get("score"):
biz_kpis = [k for k in self.result.plan_vs_actual if k["area"].lower() in ("business", "revenue", "sales", "leads")]
if biz_kpis:
on_track_pct = sum(1 for k in biz_kpis if k["status"] in ("on_track", "exceeded")) / len(biz_kpis) * 100
score = on_track_pct
status = "strong" if score >= 80 else "on_track" if score >= 60 else "at_risk" if score >= 40 else "critical"
self.result.dimension_scores.append(asdict(DimensionScore(
dimension=dim_key, label=dim_info["label"],
weight=dim_info["weight"], score=round(score, 1),
status=status,
evidence=user_input.get("evidence", []),
business_implication=user_input.get("implication", ""),
)))
total_weight += dim_info["weight"]
weighted_sum += score * dim_info["weight"]
self.result.overall_score = round(weighted_sum / total_weight, 1) if total_weight > 0 else 0
os = self.result.overall_score
self.result.overall_status = "Strong quarter" if os >= 80 else "On track" if os >= 60 else "At risk" if os >= 40 else "Critical — action required"
def _build_learnings(self):
self.result.what_worked = self.config.get("what_worked", [])
self.result.what_didnt = self.config.get("what_didnt", [])
# Auto-generate key learnings from plan_vs_actual
learnings = []
exceeded = [k for k in self.result.plan_vs_actual if k["status"] == "exceeded"]
missed = [k for k in self.result.plan_vs_actual if k["status"] == "missed"]
for k in exceeded[:3]:
learnings.append(f"Outperformed on {k['metric']} ({k['gap_pct']:+.1f}% vs plan) — {k['explanation'] or 'investigate success drivers for replication'}")
for k in missed[:3]:
learnings.append(f"Missed {k['metric']} by {abs(k['gap_pct']):.1f}% — {k['explanation'] or 'root cause analysis required'}")
self.result.key_learnings = learnings + self.config.get("additional_learnings", [])
def _build_priorities(self):
proposed = self.config.get("proposed_priorities", [])
for p in proposed:
impact = p.get("impact", 5)
readiness = p.get("readiness", 5)
urgency = p.get("urgency", 5)
score = impact * readiness * urgency / 10
self.result.priorities.append(asdict(NextPriority(
priority=p.get("priority", ""),
why_it_matters=p.get("why", ""),
required_action=p.get("action", ""),
owner=p.get("owner", "TBD"),
impact_score=impact, readiness_score=readiness, urgency_score=urgency,
priority_score=round(score, 1),
)))
self.result.priorities.sort(key=lambda x: -x["priority_score"])
self.result.decisions_needed = self.config.get("decisions_needed", [])
def _build_scope_review(self):
self.result.change_orders = self.config.get("change_orders", [])
self.result.scope_drift_items = self.config.get("scope_drift", [])
def _build_measurement(self):
level = self.config.get("measurement_level", "attribution")
level_text = {
"delivery": "Delivery only — can prove execution, not impact",
"attribution": "Attribution — platforms report conversions, but incrementality not validated",
"correlation": "Correlation — performance correlated with campaigns, but causation not proven",
"incrementality": "Incrementality — causal impact validated through test or MMM",
}
self.result.measurement_confidence = level_text.get(level, level_text["attribution"])
self.result.measurement_caveats = self.config.get("measurement_caveats", [
"Platform ROAS may overstate incremental impact by 30-80%",
"Recommend incrementality test next quarter to validate",
])
def main():
parser = argparse.ArgumentParser(description="QBR Builder")
parser.add_argument("--input", "-i", required=True)
parser.add_argument("--output", "-o", default=None)
args = parser.parse_args()
with open(args.input) as f:
config = json.load(f)
builder = QBRBuilder(config)
result = builder.build()
if args.output:
with open(args.output, "w") as f:
f.write(result.to_json())
print(f"✅ QBR built → {args.output}")
print(f" {result.client_name} — {result.quarter}")
print(f" Overall: {result.overall_score}/100 ({result.overall_status})")
print(f" KPIs: {result.kpis_on_track}/{result.total_kpis} on track, {result.kpis_behind} behind")
print(f" Learnings: {len(result.key_learnings)} | Priorities: {len(result.priorities)}")
for d in result.dimension_scores:
emoji = {"strong": "🟢", "on_track": "🟡", "at_risk": "🟠", "critical": "🔴"}
print(f" {emoji.get(d['status'], '⚪')} {d['label']}: {d['score']}/100 [{d['status']}]")
else:
print(result.to_json())
if __name__ == "__main__":
main()
SKILL.md
---
name: qbr-generator
description: Generates executive quarterly business reviews that synthesize performance, delivery, media, CRM, creative, operations, finance, risks, decisions, learnings, and next-quarter priorities. Use when preparing QBRs, leadership reviews, client business reviews, board-style updates, or quarterly growth narratives. Use pptx, excel and word generation tools as needed to create executive-ready deliverables. Also trigger when someone says "prepare the QBR", "quarterly review", "client business review", "what happened this quarter", "Q[N] results", "prepare the deck for the client", or "quarterly performance summary". Even casual phrasing like "how did we do this quarter?", "prep for the quarterly", "what's the Q[N] story?", or "summarize the quarter" should activate this skill.
---
# QBR Generator
Create a quarterly business review that functions like a construction progress review: what was planned, what was delivered, what changed, what value was created, what leaked, what risks remain, and what decisions are required next. Convert 13 weeks of fragmented data into a C-level growth narrative.
## How This Skill Orchestrates
This is the **terminal synthesis skill** of the OS — it consumes outputs from ALL 15 upstream skills to produce the quarterly narrative.
1. **Upstream context** (Claude — PRIMARY): Pull data from every skill used during the quarter — control tower health (13 weeks), margin simulation, scope audit, media routing, CRM journeys, audience segments, creative supply, measurement results, performance diagnoses, executive memos, change orders
2. **Script execution** (`scripts/qbr_builder.py`): Plan vs actual comparison, KPI gap analysis, 6-dimension executive scorecard (weighted scoring), learning extraction, next-quarter priority ranking (Impact × Readiness × Urgency)
3. **Reference lookup** (`references/qbr_framework.md`): QBR outline template (14-section structure), plan vs actual methodology, scorecard framework, upstream context mapping, benchmark search protocol
4. **Reference lookup** (`references/quarterly_planning.md`): Learning extraction framework (Observation → Insight → Implication), priority scoring rules, standard priorities catalog, QBR-to-action bridge (connects QBR findings to next-quarter skill triggers)
5. **Web search** (Claude — MANDATORY): Search for `"[INDUSTRY] [COUNTRY] Q[N] [YEAR]"`, `"Kantar Worldpanel [CATEGORY]"`, `"Nielsen ad intel [INDUSTRY]"` for market context
6. **File generation** (Claude): Generate PPTX deck, Excel scorecard, or Word document using respective skills. Default to inline visual + PPTX
7. **Visual output** (Visualizer): Executive scorecard dashboard + plan vs actual table + priority matrix
**Model decision**: **Executive layer → LLM narrative generation + Governance → risk scoring** (scorecard). Not ML — the script does structured comparison (plan vs actual) and weighted scoring (scorecard). The LLM generates the narrative that connects data points into a coherent story. The 70/30 split: ~70% AI-operated (data compilation, scorecard calculation, learning extraction, slide generation), ~30% human (strategic interpretation, client relationship framing, next-quarter negotiation).
## Quick Reference
| Resource | Purpose | Usage |
|----------|---------|-------|
| `scripts/qbr_builder.py` | Consolidated QBR engine — plan vs actual (4-status classification), 6-dimension scorecard (weighted 25/20/15/10/15/15), auto-learning extraction from gaps, priority scoring (I×R×U), scope/CO review, measurement confidence | `python qbr_builder.py --input config.json --output qbr.json` |
| `references/qbr_framework.md` | 14-section QBR outline, plan vs actual methodology, scorecard interpretation guide, full upstream context mapping (15 skills → QBR), benchmark search protocol | Read for QBR structure and data sourcing |
| `references/quarterly_planning.md` | Learning framework (Observation→Insight→Implication), anti-patterns, priority scoring rules, standard priorities catalog, QBR-to-action bridge connecting findings to next-quarter OS execution | Read for learning quality and planning |
## Process
### Step 1 — Reconstruct the Plan
What was the original plan for the quarter? Pull from SOW, media plan, CRM targets, creative timeline. The plan IS the baseline against which everything is compared.
### Step 2 — Compare Plan vs Actual
For every KPI, metric, and deliverable: planned → actual → gap → status (exceeded/on_track/behind/missed). Run the QBR builder for automated gap analysis.
### Step 3 — Score the Scorecard
Score each of 6 dimensions (0-100) based on evidence. Calculate weighted overall score. Status: Strong (≥80), On track (60-79), At risk (40-59), Critical (<40).
### Step 4 — Compile Workstream Reviews
For each workstream (media, CRM, creative, operations), summarize: what worked, what didn't, learning, and next action. Pull from upstream skill outputs.
### Step 5 — Review Scope and Changes
List all change orders, scope drift, unpriced work, and commercial implications. Connect to margin-simulation and scope-audit outputs.
### Step 6 — State Measurement Confidence
Using the evidence hierarchy from measurement-incrementality, state what can and cannot be claimed about the quarter's results.
### Step 7 — Extract Learnings
Apply the Observation → Insight → Implication framework. Avoid vanity learnings ("CTR was 2.1%"). Every learning must lead to an action.
### Step 8 — Rank Next-Quarter Priorities
Score each proposed priority on Impact × Readiness × Urgency. Rank and classify as must-do / should-do / could-do / deprioritize.
### Step 9 — Define Leadership Decisions
List the explicit decisions leadership must make: budget approval, scope change, team restructuring, test approval, strategy pivot.
### Step 10 — Generate the QBR
Produce the full QBR in the requested format(s): inline visual artifact, PPTX deck, Excel scorecard, Word document.
## Output Format
Produce in THREE forms: **inline visual dashboard** (Visualizer), **downloadable PPTX** (via pptx skill), and **structured markdown**.
### Visual Dashboard (Primary)
Render as inline HTML widget:
- **Header** with client name, quarter, overall score badge, and status
- **Executive scorecard** — 6 dimension cards with score, status badge, and top evidence point
- **Plan vs Actual table** — rows per KPI with planned/actual/gap/status, color-coded
- **Learnings section** — What worked (green) / What didn't (red) / Key insights
- **Next-quarter priorities** — ranked cards with I×R×U score and owner
- **Decisions needed** — bulleted list with urgency badges
- **`sendPrompt()` buttons**: "Generate PPTX deck for this QBR" → triggers pptx generation, "Run performance diagnosis for [at-risk dimension]" → `performance-diagnosis`, "Model next-quarter scenarios" → `executive-growth-memo`
### PPTX Deck (Secondary)
When user requests a deck, use the `pptx` skill to generate:
1. Title slide (client, quarter, date)
2. Executive summary (1 slide, 3-4 bullets)
3. Scorecard (6 dimensions, visual)
4. Plan vs Actual (data table)
5. Business performance (1-2 slides)
6. Media review (1-2 slides)
7. CRM review (1 slide)
8. Operational + financial (1 slide)
9. Learnings (1 slide)
10. Next quarter priorities (1 slide)
11. Decisions needed (1 slide)
### Markdown Report (Tertiary)
```
## 📊 QUARTERLY BUSINESS REVIEW — [Client] — [Quarter]
### Executive summary
[1 paragraph: overall verdict, key metric, main learning, top priority]
### Quarter scorecard
| Dimension | Score | Status | Key evidence | Business implication |
Overall: [X]/100 — [status]
### Plan vs actual
| Area | Metric | Planned | Actual | Gap | Gap % | Status |
KPIs on track: [X]/[Y] | Behind: [Z]
### Business performance
[Revenue, leads, sales narrative with benchmark context]
### Media review
[Efficiency, delivery, allocation, waste — from media-routing-planner]
### CRM / lifecycle
[Journey performance, email metrics — from crm-journey-architect]
### Creative & content
[Performance, fatigue, production — from creative-supply-planner]
### Operations & finance
[SLA, timeline, budget pacing, margin]
### Scope & changes
[COs, drift, commercial implications]
### Measurement confidence
[Evidence level + caveats — from measurement-incrementality]
### Learnings
| # | Observation | Insight | Implication |
### Next-quarter priorities
| Priority | I×R×U score | Action | Owner |
### Decisions needed
[Explicit asks with deadline]
```
## Examples
**Example 1 — Strong quarter:**
User provides KPI data showing 4/5 KPIs on track, ROAS above target. QBR score: 78/100 (On track). Narrative: "Solid quarter with media efficiency exceeding plan. CRM underperformed — journey completion at 35% vs 50% target. Priority: redesign onboarding journey."
**Example 2 — Difficult quarter:**
User provides data: revenue missed by 22%, CPA 40% above target, 2 scope changes unpriced. QBR score: 42/100 (At risk). Narrative: "Quarter impacted by audience saturation + creative fatigue + unpriced scope drift. Recovery plan: creative refresh (immediate), audience expansion (Week 1-2), scope restructuring (CO pending)."
**Example 3 — Full OS synthesis:**
All 15 skills have been used during the quarter. Claude synthesizes 13 weeks of control tower data, margin simulations, scope audits, media optimization, CRM journeys, creative supply, measurement results, and performance diagnoses into a comprehensive QBR.
## Skill Chaining
| Direction | Skill | Connection |
|-----------|-------|------------|
| Upstream | ALL 15 skills | QBR consumes everything produced during the quarter |
| Downstream | `executive-growth-memo` | QBR findings → C-level memo for board |
| Downstream | `performance-diagnosis` | At-risk dimensions → root cause analysis |
| Downstream | `media-routing-planner` | Next-quarter media optimization |
| Downstream | `scope-audit` | Scope drift → formal scope review |
| Downstream | `change-order-generator` | Unpriced work → CO pricing |
| Downstream | `measurement-incrementality` | Measurement gaps → test design |