Campaign launch qa

Campaign Launch QA

Validate campaign readiness across 10 execution layers — brief, audience, creative, media, landing page, CRM/journey, tracking, approvals, reporting, and operations — and issue a scored go/no-go recommendation before any campaign goes live.

How This Skill Orchestrates

This skill is the governance gate of the OS. It runs after all other skills have done their work:

1. Script execution (scripts/qa_scorer.py): Scores readiness across 10 layers with 50+ checklist items, detects blockers, calculates weighted readiness score, issues go/no-go
2. Reference lookup (references/tech_stack_enablers.md): When the user names their tech stack (SFMC, AJO, AEM, HubSpot), load the platform-specific enablers checklist and validate against it
3. Upstream context (Claude): Pull campaign details from earlier skills — scope from scope-audit, team from fte-capacity-sizing, budget validation from margin-simulation
4. Visual output (Visualizer): Render the QA dashboard as a readiness scorecard with layer-by-layer results

No ML models are used. This is a governance / anomaly detection problem solved with rule-based risk scoring — a weighted checklist with critical-item blocker logic. The checklist itself is the model.

70/30 split on QA: ~62% of QA items can be automated by AI agents (UTM validation, tag firing, link checks, spec verification, rendering tests), while ~38% require human judgment (creative quality, brand compliance, strategic alignment, client approvals).

Quick Reference

Resource	Purpose	Usage
scripts/qa_scorer.py	QA scoring engine — 10 validation layers, 50+ items, weighted readiness score (0-100), blocker detection, go/no-go decision	python qa_scorer.py --input checklist.json --campaign "Summer 2026" --tech sfmc --output qa.json
references/tech_stack_enablers.md	Platform-specific enablers: SFMC, AJO, AEM, HubSpot — minimum requirements, common failures, condensed checklist per platform	Read when user names their tech stack (Step 6.1)

How to Use the Script

Build a checklist JSON from the user's campaign, then run the scorer:

import sys
sys.path.insert(0, "<skill-path>/scripts")
from qa_scorer import QAScorer

# Each item needs an id (matching the built-in checklist) and a status
checklist = [
    {"id": "brief_approved", "status": "passed"},
    {"id": "objectives_defined", "status": "passed"},
    {"id": "budget_confirmed", "status": "passed"},
    {"id": "creative_approved", "status": "failed", "notes": "Waiting on client feedback"},
    {"id": "utm_structure", "status": "passed"},
    {"id": "pixels_firing", "status": "pending"},
    # ... add all relevant items
]

scorer = QAScorer(checklist, campaign_name="Summer Sale 2026", tech_stack="sfmc")
result = scorer.score()
# result.readiness_score, result.decision, result.blockers, result.layers, etc.

Items not provided default to pending. Layers can be skipped if not applicable (e.g., skip_layers=["crm_journey"] for a media-only campaign).

Trigger Conditions

Activate this skill when:

• A campaign, journey, email, media plan, or activation is about to launch
• The user asks for a pre-launch checklist or go/no-go assessment
• Upstream skills have completed (scope audited, team sized, margin validated) and execution is next
• The user mentions readiness, QA, final check, or pre-launch validation

Validation Process

Step 1 — Validate Brief & Strategy

Confirm the campaign brief has been approved, objectives and KPIs are defined, budget is confirmed, timeline is locked, and any legal/regulatory review is complete.

Step 2 — Validate Target Audience

Confirm audience segments are defined, audience size is sufficient, exclusion/suppression lists are applied, frequency caps are configured, and data consent is verified.

Step 3 — Validate Creative Assets

Confirm creative is client-approved, specs match platform requirements, copy is proofread, CTAs link correctly, all format variations are produced, and accessibility is checked.

Step 4 — Validate Media Plan

Confirm media plan is approved, budget is loaded in platforms, targeting is configured, bid strategy is set, flight dates are correct, and pacing is validated.

Step 5 — Validate Landing Page / Destination

Confirm the destination is live, mobile-responsive, loads in under 3 seconds, the conversion action works end-to-end, and privacy policies are present.

Step 6 — Validate CRM / Journey

Confirm journey logic is mapped and reviewed, templates are tested across email clients, segmentation rules are validated, triggers are tested, unsubscribe works, and send throttling is configured.

Step 6.1 — Tech Stack Sweep

This is critical: the user must name the tech stack (SFMC, AJO, AEM, HubSpot, or other). Once named, read references/tech_stack_enablers.md and validate against the platform-specific enablers checklist. This catches platform-level failures that generic QA misses — things like SFMC subscriber key mismatches, AJO consent policy gaps, AEM dispatcher cache issues, or HubSpot personalization token fallbacks.

If the user hasn't named the tech stack, ask before proceeding. This step is not optional — platform-specific validation prevents the most common and most damaging launch failures.

Step 7 — Validate Tracking & UTMs

Confirm UTMs follow naming convention, no duplicates exist, conversion pixels are firing, GA4/analytics events are verified in debug mode, attribution model is confirmed, and GTM is published.

Step 8 — Validate Approvals

Confirm client sign-off is received in writing, legal/compliance has signed off (if required), and internal team review is complete.

Step 9 — Validate Reporting Setup

Confirm dashboard/reporting template is ready, reporting owner is assigned, KPI targets are set, and performance alert rules are configured.

Step 10 — Issue Go / No-Go

Run the scorer to calculate the weighted readiness score:

Score	Decision	Meaning
≥ 85% and 0 blockers	Go	All critical items passed, launch is clear
60-84% or ≤ 5 pending	Go with risk	Acceptable but documented risk
< 60% or any blockers	No-Go	Critical failures prevent launch

Blocker rule: Any critical item that fails is an automatic No-Go regardless of score. Blockers must be resolved before the decision can change.

Output Format

Produce the QA assessment in TWO forms: an inline visual artifact and a structured markdown checklist.

Visual Artifact (Primary)

Render the QA scorecard as an inline HTML widget using the Visualizer:

• A header bar color-coded by decision: green (Go), amber (Go with risk), red (No-Go)
• A readiness score as a large metric (e.g., "87%") with the decision badge
• A layer progress grid — 10 mini-bars (one per layer) showing passed/failed/pending proportions, color-coded
• A blockers section — if any, each blocker as a red row with layer, item label, and notes
• A AI/Human split indicator — showing what % of the checklist was AI-checkable vs. human-required
• A pending items section — items still unresolved, with layer and label
• An action footer with sendPrompt() buttons:
  • "Show me the tech stack enablers checklist for [platform]" → loads platform-specific reference
  • "Re-run QA after fixing blockers" → re-scores with updated statuses
  • "Draft launch approval email for [campaign]" → generates client-facing go confirmation

Use CSS variables for light/dark mode.

Markdown Checklist (Secondary)

After the visual artifact, produce the full QA checklist:

## ✅ CAMPAIGN LAUNCH QA — [Campaign Name]

### Launch decision
[Go / Go with risk / No-Go] — Readiness: [X]%
[Decision rationale]

### Blockers (must resolve)
[If any: layer | item | status | notes]

### Layer-by-layer checklist

#### 1. Brief & strategy [X/Y passed]
- [✅/❌/⏳] Item label — notes

#### 2. Target audience [X/Y passed]
...

[Continue for all 10 layers]

### Tech stack validation ([platform])
[Platform-specific items from reference]

### AI/Human QA split
| Metric | Value |
|--------|-------|
| AI-checkable items | [X] ([Y]%) |
| Human-required items | [X] ([Y]%) |
| Total items | [X] |

### Pending items requiring resolution
[List with owner assignment recommendation]

### Post-launch checks
- 24-hour performance check: [owner]
- 72-hour optimization review: [owner]
- 7-day campaign health report: [owner]

Examples

Example 1 — Clean Go:

User: "Run QA for our Summer Sale email campaign on SFMC. Brief is approved, creative is approved, journey is tested, UTMs are set."

→ Score: 92%. Decision: Go. 0 blockers. 2 pending items (reporting dashboard, post-launch schedule). Tech stack sweep confirms SFMC enablers are met.

Example 2 — Go with risk:

User: "We're about to launch the media campaign but the client hasn't sent written approval yet and we're still waiting on final creative for 2 banner sizes."

→ Score: 71%. Decision: Go with risk. 0 critical blockers (creative not approved is critical → actually this IS a blocker). Correction: Decision: No-Go. 1 blocker: creative not approved.

Example 3 — No-Go:

User: "QA our CRM journey for AcmeAuto. Journey is built but we haven't tested the triggers, UTMs aren't set, and we don't know who owns reporting."

→ Score: 45%. Decision: No-Go. 2 blockers (triggers not tested, UTMs not set are critical tracking items). 5 pending items.

Skill Chaining

Direction	Skill	Connection
Upstream	scope-audit	Validates the campaign deliverables are in scope
Upstream	fte-capacity-sizing	Confirms the team has capacity to execute
Upstream	margin-simulation	Validates the campaign is commercially viable
Upstream	change-order-generator	Any CO items are incorporated into scope
Downstream	weekly-control-tower	Campaign enters operational tracking post-launch
Downstream	executive-growth-memo	Launch summary for leadership