claude-code-arcane 1.0.0

package/skills/cmo-advisor/scripts/marketing_budget_modeler.py

@@ -0,0 +1,440 @@
+#!/usr/bin/env python3
+"""
+Marketing Budget Modeler
+------------------------
+Allocates marketing budget across channels based on CAC efficiency and
+target MQL volume. Models conservative / moderate / aggressive scenarios.
+
+Usage:
+    python marketing_budget_modeler.py
+
+Inputs (edit INPUTS section below or extend with argparse):
+    - Annual revenue target (new ARR)
+    - Average selling price (ASP)
+    - Conversion rates by funnel stage
+    - Historical CAC per channel
+    - Channel capacity constraints (max MQLs the channel can realistically produce)
+
+Outputs:
+    - Required MQL volume by channel
+    - Budget allocation per channel per scenario
+    - LTV:CAC and payback period per channel
+    - Summary table across scenarios
+"""
+
+from __future__ import annotations
+import math
+from dataclasses import dataclass, field
+from typing import Dict, List, Tuple
+
+
+# ---------------------------------------------------------------------------
+# Data models
+# ---------------------------------------------------------------------------
+
+@dataclass
+class Channel:
+    name: str
+    cac: float              # Customer acquisition cost ($)
+    max_mqls_per_month: int # Realistic capacity ceiling (MQLs/month)
+    mql_to_close_rate: float  # Combined MQL → closed-won rate (0.0–1.0)
+    payback_months: float   # Based on ARPU × gross margin
+    ltv: float              # Lifetime value ($)
+    trend: str = "stable"   # "improving" | "stable" | "declining"
+
+
+@dataclass
+class FunnelRates:
+    mql_to_sal: float     # MQL → Sales Accepted Lead
+    sal_to_sql: float     # SAL → Sales Qualified Lead
+    sql_to_opp: float     # SQL → Opportunity
+    opp_to_close: float   # Opportunity → Closed-Won
+
+    @property
+    def mql_to_close(self) -> float:
+        return self.mql_to_sal * self.sal_to_sql * self.sql_to_opp * self.opp_to_close
+
+
+@dataclass
+class ScenarioResult:
+    name: str
+    total_budget: float
+    channel_budgets: Dict[str, float]
+    channel_mqls: Dict[str, int]
+    projected_customers: int
+    projected_arr: float
+    blended_cac: float
+    notes: List[str] = field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# INPUTS — edit these
+# ---------------------------------------------------------------------------
+
+TARGET_NEW_ARR = 3_000_000      # New ARR to generate this year ($)
+ASP_ANNUAL = 18_000             # Average annual contract value ($)
+GROSS_MARGIN = 0.75             # Product gross margin (%)
+ARPU_MONTHLY = ASP_ANNUAL / 12  # Monthly revenue per account
+
+FUNNEL = FunnelRates(
+    mql_to_sal=0.65,
+    sal_to_sql=0.45,
+    sql_to_opp=0.75,
+    opp_to_close=0.27,
+)
+
+# LTV = ARPU_monthly × gross_margin / monthly_churn_rate
+MONTHLY_CHURN = 0.012   # ~14% annual churn
+LTV = (ARPU_MONTHLY * GROSS_MARGIN) / MONTHLY_CHURN
+
+CHANNELS: List[Channel] = [
+    Channel(
+        name="Organic SEO",
+        cac=1_800,
+        max_mqls_per_month=80,
+        mql_to_close_rate=FUNNEL.mql_to_close,
+        payback_months=(1_800 / (ARPU_MONTHLY * GROSS_MARGIN)),
+        ltv=LTV,
+        trend="improving",
+    ),
+    Channel(
+        name="Paid Search",
+        cac=6_200,
+        max_mqls_per_month=60,
+        mql_to_close_rate=FUNNEL.mql_to_close,
+        payback_months=(6_200 / (ARPU_MONTHLY * GROSS_MARGIN)),
+        ltv=LTV,
+        trend="stable",
+    ),
+    Channel(
+        name="Paid Social (LinkedIn)",
+        cac=8_500,
+        max_mqls_per_month=35,
+        mql_to_close_rate=FUNNEL.mql_to_close,
+        payback_months=(8_500 / (ARPU_MONTHLY * GROSS_MARGIN)),
+        ltv=LTV,
+        trend="declining",
+    ),
+    Channel(
+        name="Outbound SDR",
+        cac=5_100,
+        max_mqls_per_month=50,
+        mql_to_close_rate=FUNNEL.mql_to_close,
+        payback_months=(5_100 / (ARPU_MONTHLY * GROSS_MARGIN)),
+        ltv=LTV,
+        trend="stable",
+    ),
+    Channel(
+        name="Events / Field",
+        cac=9_800,
+        max_mqls_per_month=25,
+        mql_to_close_rate=FUNNEL.mql_to_close,
+        payback_months=(9_800 / (ARPU_MONTHLY * GROSS_MARGIN)),
+        ltv=LTV,
+        trend="stable",
+    ),
+    Channel(
+        name="Partner / Channel",
+        cac=3_400,
+        max_mqls_per_month=30,
+        mql_to_close_rate=FUNNEL.mql_to_close,
+        payback_months=(3_400 / (ARPU_MONTHLY * GROSS_MARGIN)),
+        ltv=LTV,
+        trend="improving",
+    ),
+    Channel(
+        name="Content / Inbound",
+        cac=2_600,
+        max_mqls_per_month=45,
+        mql_to_close_rate=FUNNEL.mql_to_close,
+        payback_months=(2_600 / (ARPU_MONTHLY * GROSS_MARGIN)),
+        ltv=LTV,
+        trend="improving",
+    ),
+]
+
+
+# ---------------------------------------------------------------------------
+# Core calculations
+# ---------------------------------------------------------------------------
+
+def customers_needed(target_arr: float, asp: float) -> int:
+    return math.ceil(target_arr / asp)
+
+
+def mqls_needed_total(customers: int, mql_to_close: float) -> int:
+    return math.ceil(customers / mql_to_close)
+
+
+def ltv_to_cac(ltv: float, cac: float) -> float:
+    return ltv / cac if cac > 0 else 0.0
+
+
+def score_channel(ch: Channel) -> float:
+    """
+    Score a channel for budget priority.
+    Higher = more efficient. Used to rank allocation order.
+    Factors: LTV:CAC ratio, trend multiplier, capacity.
+    """
+    ratio = ltv_to_cac(ch.ltv, ch.cac)
+    trend_mult = {"improving": 1.2, "stable": 1.0, "declining": 0.7}.get(ch.trend, 1.0)
+    return ratio * trend_mult
+
+
+def allocate_mqls(
+    channels: List[Channel],
+    total_mqls_needed: int,
+    budget_multiplier: float = 1.0,
+) -> Tuple[Dict[str, int], Dict[str, float]]:
+    """
+    Allocate MQL targets across channels in priority order (best LTV:CAC first).
+    budget_multiplier: 0.7 = conservative, 1.0 = moderate, 1.3 = aggressive.
+    Returns (channel → MQLs, channel → budget).
+    """
+    ranked = sorted(channels, key=score_channel, reverse=True)
+    remaining = total_mqls_needed
+    channel_mqls: Dict[str, int] = {}
+    channel_budget: Dict[str, float] = {}
+
+    for ch in ranked:
+        if remaining <= 0:
+            channel_mqls[ch.name] = 0
+            channel_budget[ch.name] = 0.0
+            continue
+        # Apply capacity ceiling scaled by multiplier (aggressive = push capacity)
+        capacity = int(ch.max_mqls_per_month * 12 * budget_multiplier)
+        allocated = min(remaining, capacity)
+        channel_mqls[ch.name] = allocated
+        channel_budget[ch.name] = allocated * ch.cac
+        remaining -= allocated
+
+    return channel_mqls, channel_budget
+
+
+def build_scenario(
+    name: str,
+    channels: List[Channel],
+    total_mqls: int,
+    multiplier: float,
+    notes: List[str],
+) -> ScenarioResult:
+    channel_mqls, channel_budget = allocate_mqls(channels, total_mqls, multiplier)
+
+    total_budget = sum(channel_budget.values())
+    total_mqls_allocated = sum(channel_mqls.values())
+    projected_customers = math.floor(total_mqls_allocated * FUNNEL.mql_to_close)
+    projected_arr = projected_customers * ASP_ANNUAL
+
+    # Blended CAC = total budget / customers acquired
+    blended_cac = total_budget / projected_customers if projected_customers > 0 else 0.0
+
+    return ScenarioResult(
+        name=name,
+        total_budget=total_budget,
+        channel_budgets=channel_budget,
+        channel_mqls=channel_mqls,
+        projected_customers=projected_customers,
+        projected_arr=projected_arr,
+        blended_cac=blended_cac,
+        notes=notes,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Reporting
+# ---------------------------------------------------------------------------
+
+def fmt_currency(n: float) -> str:
+    if n >= 1_000_000:
+        return f"${n/1_000_000:.2f}M"
+    if n >= 1_000:
+        return f"${n/1_000:.1f}K"
+    return f"${n:.0f}"
+
+
+def fmt_ratio(n: float) -> str:
+    return f"{n:.1f}x"
+
+
+def print_header(title: str) -> None:
+    width = 72
+    print("\n" + "=" * width)
+    print(f"  {title}")
+    print("=" * width)
+
+
+def print_channel_table(channels: List[Channel]) -> None:
+    print_header("Channel Analysis — Current State")
+    header = f"{'Channel':<25} {'CAC':>8} {'Payback':>9} {'LTV:CAC':>8} {'Cap/mo':>7} {'Trend':>10}"
+    print(header)
+    print("-" * 72)
+    for ch in sorted(channels, key=score_channel, reverse=True):
+        ratio = ltv_to_cac(ch.ltv, ch.cac)
+        flag = ""
+        if ratio < 1:
+            flag = " ⚠ LOSS"
+        elif ratio >= 6:
+            flag = " ★ STRONG"
+        elif ratio >= 3:
+            flag = " ✓"
+        print(
+            f"{ch.name:<25} {fmt_currency(ch.cac):>8} "
+            f"{ch.payback_months:>7.1f}mo {fmt_ratio(ratio):>8} "
+            f"{ch.max_mqls_per_month:>7} {ch.trend:>10}{flag}"
+        )
+
+
+def print_funnel_summary(customers: int, mqls: int) -> None:
+    print_header("Funnel Requirements")
+    print(f"  Target new ARR:          {fmt_currency(TARGET_NEW_ARR)}")
+    print(f"  Average selling price:   {fmt_currency(ASP_ANNUAL)}")
+    print(f"  New customers needed:    {customers}")
+    print(f"  Funnel MQL→Close rate:   {FUNNEL.mql_to_close:.1%}")
+    print(f"  Total MQLs needed:       {mqls}")
+    print(f"\n  Funnel stage rates:")
+    print(f"    MQL → SAL:             {FUNNEL.mql_to_sal:.0%}")
+    print(f"    SAL → SQL:             {FUNNEL.mql_to_sal * FUNNEL.sal_to_sql:.0%}")
+    print(f"    SQL → Opportunity:     {FUNNEL.mql_to_sal * FUNNEL.sal_to_sql * FUNNEL.sql_to_opp:.0%}")
+    print(f"    Opportunity → Close:   {FUNNEL.mql_to_close:.0%}")
+    print(f"\n  LTV (estimated):         {fmt_currency(LTV)}")
+    print(f"  Monthly churn:           {MONTHLY_CHURN:.1%}  ({MONTHLY_CHURN*12:.0%} annualized)")
+
+
+def print_scenario(result: ScenarioResult, channels: List[Channel]) -> None:
+    print_header(f"Scenario: {result.name}")
+    print(f"  Total marketing budget:  {fmt_currency(result.total_budget)}")
+    print(f"  Projected customers:     {result.projected_customers}")
+    print(f"  Projected new ARR:       {fmt_currency(result.projected_arr)}")
+    print(f"  Blended CAC:             {fmt_currency(result.blended_cac)}")
+    blended_ltv_cac = LTV / result.blended_cac if result.blended_cac > 0 else 0
+    blended_payback = result.blended_cac / (ARPU_MONTHLY * GROSS_MARGIN)
+    print(f"  Blended LTV:CAC:         {fmt_ratio(blended_ltv_cac)}", end="")
+    if blended_ltv_cac < 1:
+        print("  ⚠ BELOW BREAK-EVEN")
+    elif blended_ltv_cac < 3:
+        print("  △ MARGINAL")
+    elif blended_ltv_cac >= 3:
+        print("  ✓ HEALTHY")
+    else:
+        print()
+    print(f"  Blended payback:         {blended_payback:.1f} months")
+    if result.notes:
+        print(f"\n  Notes:")
+        for note in result.notes:
+            print(f"    • {note}")
+
+    print(f"\n  {'Channel':<25} {'MQLs':>6} {'Budget':>10} {'% of Budget':>12} {'LTV:CAC':>8}")
+    print("  " + "-" * 65)
+    for ch in sorted(channels, key=score_channel, reverse=True):
+        mqls = result.channel_mqls.get(ch.name, 0)
+        budget = result.channel_budgets.get(ch.name, 0.0)
+        pct = (budget / result.total_budget * 100) if result.total_budget > 0 else 0
+        ratio = ltv_to_cac(ch.ltv, ch.cac)
+        print(
+            f"  {ch.name:<25} {mqls:>6} {fmt_currency(budget):>10} "
+            f"{pct:>11.1f}% {fmt_ratio(ratio):>8}"
+        )
+
+
+def print_scenario_comparison(scenarios: List[ScenarioResult]) -> None:
+    print_header("Scenario Comparison")
+    header = f"{'Scenario':<18} {'Budget':>10} {'Customers':>10} {'ARR':>10} {'Blended CAC':>12} {'LTV:CAC':>8} {'Payback':>9}"
+    print(header)
+    print("-" * 82)
+    for s in scenarios:
+        blended_ltv_cac = LTV / s.blended_cac if s.blended_cac > 0 else 0
+        blended_payback = s.blended_cac / (ARPU_MONTHLY * GROSS_MARGIN)
+        print(
+            f"{s.name:<18} {fmt_currency(s.total_budget):>10} "
+            f"{s.projected_customers:>10} {fmt_currency(s.projected_arr):>10} "
+            f"{fmt_currency(s.blended_cac):>12} {fmt_ratio(blended_ltv_cac):>8} "
+            f"{blended_payback:>7.1f}mo"
+        )
+
+
+def print_recommendations(channels: List[Channel]) -> None:
+    print_header("Channel Recommendations")
+    scale = [ch for ch in channels if score_channel(ch) >= 1.5 and ch.trend in ("improving", "stable")]
+    hold = [ch for ch in channels if 0.8 <= score_channel(ch) < 1.5 or (ch.trend == "stable" and ltv_to_cac(ch.ltv, ch.cac) >= 3)]
+    cut = [ch for ch in channels if ltv_to_cac(ch.ltv, ch.cac) < 2 or ch.trend == "declining"]
+    # Deduplicate
+    hold = [ch for ch in hold if ch not in scale]
+    cut = [ch for ch in cut if ch not in scale and ch not in hold]
+
+    if scale:
+        print("  SCALE (strong LTV:CAC, improving or stable trend):")
+        for ch in scale:
+            print(f"    + {ch.name}  [LTV:CAC {fmt_ratio(ltv_to_cac(ch.ltv, ch.cac))}, payback {ch.payback_months:.0f}mo]")
+    if hold:
+        print("  HOLD (monitor — adequate but not outstanding):")
+        for ch in hold:
+            print(f"    = {ch.name}  [LTV:CAC {fmt_ratio(ltv_to_cac(ch.ltv, ch.cac))}, trend: {ch.trend}]")
+    if cut:
+        print("  CUT or REDUCE (poor LTV:CAC or declining):")
+        for ch in cut:
+            print(f"    - {ch.name}  [LTV:CAC {fmt_ratio(ltv_to_cac(ch.ltv, ch.cac))}, trend: {ch.trend}]")
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    customers = customers_needed(TARGET_NEW_ARR, ASP_ANNUAL)
+    total_mqls = mqls_needed_total(customers, FUNNEL.mql_to_close)
+
+    print_channel_table(CHANNELS)
+    print_funnel_summary(customers, total_mqls)
+
+    scenarios = [
+        build_scenario(
+            name="Conservative",
+            channels=CHANNELS,
+            total_mqls=total_mqls,
+            multiplier=0.7,
+            notes=[
+                "Prioritizes lowest CAC channels only.",
+                "May not reach MQL target — expect ~70% of goal.",
+                "Best for capital-constrained orgs or short runway.",
+            ],
+        ),
+        build_scenario(
+            name="Moderate",
+            channels=CHANNELS,
+            total_mqls=total_mqls,
+            multiplier=1.0,
+            notes=[
+                "Balanced allocation — efficiency-first but full MQL target.",
+                "Recommended baseline. Revisit Q2 based on actuals.",
+            ],
+        ),
+        build_scenario(
+            name="Aggressive",
+            channels=CHANNELS,
+            total_mqls=total_mqls,
+            multiplier=1.4,
+            notes=[
+                "Pushes all channels toward capacity ceiling.",
+                "Higher spend on lower-efficiency channels to hit volume.",
+                "Requires > 18-month runway to justify payback period.",
+            ],
+        ),
+    ]
+
+    for scenario in scenarios:
+        print_scenario(scenario, CHANNELS)
+
+    print_scenario_comparison(scenarios)
+    print_recommendations(CHANNELS)
+
+    print("\n" + "=" * 72)
+    print("  Key questions before finalizing budget:")
+    print("    1. What is the payback period the CFO/board will accept?")
+    print("    2. Is CAC for declining-trend channels actually recoverable?")
+    print("    3. Does the moderate scenario require sales headcount increase?")
+    print("    4. Which channels have capacity to absorb 20% more spend?")
+    print("=" * 72 + "\n")
+
+
+if __name__ == "__main__":
+    main()

package/skills/code-review/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: code-review
+description: "Architectural and quality code review: standards compliance, SOLID principles, testability, performance."
+category: "workflow"
+argument-hint: "[path-to-file-or-directory]"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Bash, Task
+agent: lead-programmer
+---
+
+## Phase 1: Load Target Files
+
+Read target file(s) in full. Read CLAUDE.md for project coding standards.
+
+## Phase 2: Identify Engine Specialists
+
+Read `.claude/docs/technical-preferences.md` → `## Engine Specialists`. Note Primary, Language/Code, Shader, UI specialists. If `[TO BE CONFIGURED]` → skip engine specialist steps.
+
+## Phase 3: ADR Compliance Check
+
+Search for `ADR-NNN` patterns in story file, commits, headers. No references → skip.
+
+Per referenced ADR, read Decision + Consequences sections, classify deviations:
+
+| Severity | Meaning |
+|----------|---------|
+| ARCHITECTURAL VIOLATION (BLOCKING) | Uses pattern explicitly rejected in ADR |
+| ADR DRIFT (WARNING) | Meaningfully diverges from chosen approach |
+| MINOR DEVIATION (INFO) | Small difference, doesn't affect architecture |
+
+## Phase 4: Standards Compliance
+
+Identify system category (engine, gameplay, AI, networking, UI, tools). Check: doc comments on public methods, cyclomatic complexity <10/method, methods ≤40 lines, DI (no static singletons), config from data files, interfaces exposed.
+
+## Phase 5: Architecture and SOLID
+
+- **Architecture**: correct dependency direction, no circular deps, proper layer separation, events for cross-system communication, consistent patterns
+- **SOLID**: SRP, OCP, LSP, ISP, DIP — check each principle
+
+## Phase 6: Game-Specific Concerns
+
+Frame-rate independence (delta time), no allocations in hot paths, null/empty handling, thread safety, resource cleanup.
+
+## Phase 7: Specialist Reviews (Parallel)
+
+Spawn applicable specialists via Task simultaneously:
+- Primary language files → Language/Code Specialist
+- Shader files → Shader Specialist
+- UI code → UI Specialist
+- Cross-cutting → Primary Specialist
+
+### QA Testability Review
+
+For Logic/Integration stories, spawn `qa-tester` in parallel. Evaluate: test hooks exposed, QA test cases map to code paths, acceptance criteria testable, new edge cases covered, side effects tested. For Visual/UI stories: verify manual steps are reachable.
+
+## Phase 8: Output Review
+
+Report sections: Engine Specialist Findings, Testability, ADR Compliance, Standards Compliance (X/6), Architecture, SOLID, Game-Specific Concerns, Positive Observations, Required Changes (violations always here), Suggestions. Verdict: APPROVED / APPROVED WITH SUGGESTIONS / CHANGES REQUIRED.
+
+This skill is read-only.
+
+## Phase 9: Next Steps
+
+- APPROVED → `/story-done [story-path]`
+- CHANGES REQUIRED → fix issues, re-run `/code-review`
+- ARCHITECTURAL VIOLATION → `/architecture-decision` to record correct approach

package/skills/cold-email/SKILL.md

@@ -0,0 +1,178 @@
+---
+name: cold-email
+description: "Write and optimize B2B cold outreach emails and follow-up sequences. For lifecycle/nurture emails to opted-in subscribers use email-sequence."
+argument-hint: ""
+category: "marketing-growth"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Bash, Write, Edit
+---
+
+# Cold Email Outreach
+
+You are an expert in B2B cold email outreach. Your goal is to help write, build, and iterate on cold email sequences that sound like they came from a thoughtful human — not a sales machine — and actually get replies.
+
+## Before Starting
+
+**Check for context first:**
+If `marketing-context.md` exists, read it before asking questions.
+
+Gather this context:
+
+### 1. The Sender
+- Who are they at this company? (Role, seniority — affects how they write)
+- What do they sell and who buys it?
+- Do they have any real customer results or proof points they can reference?
+- Are they sending as an individual or as a company?
+
+### 2. The Prospect
+- Who is the target? (Job title, company type, company size)
+- What problem does this person likely have that the sender can solve?
+- Is there a specific trigger or reason to reach out now? (funding, hiring, news, tech stack signal)
+- Do they have specific names and companies to personalize to, or is this a template for a segment?
+
+### 3. The Ask
+- What's the goal of the first email? (Book a call? Get a reply? Get a referral?)
+- How aggressive is the timeline? (SDR with daily send volume vs founder doing targeted outreach)
+
+---
+
+## How This Skill Works
+
+### Mode 1: Write the First Email
+When they need a single first-touch email or a template for a segment.
+
+1. Understand the ICP, the problem, and the trigger
+2. Choose the right framework (see `references/frameworks.md`)
+3. Draft first email: subject line, opener, body, CTA
+4. Review against the principles below — cut anything that doesn't earn its place
+5. Deliver: email copy + 2-3 subject line variants + brief rationale
+
+### Mode 2: Build a Follow-Up Sequence
+When they need a multi-email sequence (typically 4-6 emails).
+
+1. Start with the first email (Mode 1)
+2. Plan follow-up angles — each email needs a different angle, not just a nudge
+3. Set the gap cadence (Day 1, Day 4, Day 9, Day 16, Day 25)
+4. Write each follow-up with a standalone hook that doesn't require reading previous emails
+5. End with a breakup email that closes the loop professionally
+6. Deliver: full sequence with send gaps, subject lines, and brief on what each email does
+
+### Mode 3: Iterate from Performance Data
+When they have an active sequence and want to improve it.
+
+1. Review their current sequence emails and performance (open rate, reply rate)
+2. Diagnose: is the problem subject lines (low open rate), email body (opens but no replies), or CTA (replies but wrong outcome)?
+3. Rewrite the underperforming element
+4. Deliver: revised emails + diagnosis + test recommendation
+
+---
+
+## Core Writing Principles
+
+### 1. Write Like a Peer, Not a Vendor
+
+The moment your email sounds like marketing copy, it's over. Think about how you'd actually email a smart colleague at another company who you want to have a conversation with.
+
+**The test:** Would a friend send this to another friend in business? If the answer is no — rewrite it.
+
+- ❌ "I'm reaching out because our platform helps companies like yours achieve unprecedented growth..."
+- ✅ "Noticed you're scaling your SDR team — timing question: are you doing outbound email in-house or using an agency?"
+
+### 2. Every Sentence Earns Its Place
+
+Cold email is the wrong place to be thorough. Every sentence should do one of these jobs: create curiosity, establish relevance, build credibility, or drive to the ask. If a sentence doesn't do one of those — cut it.
+
+Read your draft aloud. The moment you hear yourself droning, stop and cut.
+
+### 3. Personalization Must Connect to the Problem
+
+Generic personalization is worse than none. "I saw you went to MIT" followed by a pitch has nothing to do with MIT. That's fake personalization.
+
+Real personalization: "I saw you're hiring three SDRs — usually a signal that you're trying to scale cold outreach. That's exactly the challenge we help with."
+
+The personalization must connect to the reason you're reaching out.
+
+### 4. Lead With Their World, Not Yours
+
+The opener should be about them — their situation, their problem, their context. Not about you or your product.
+
+- ❌ "We're a sales intelligence platform that..."
+- ✅ "Your recent TechCrunch piece mentioned you're entering the SMB market — that transition is notoriously hard to do with an enterprise-built playbook."
+
+### 5. One Ask Per Email
+
+Don't ask them to book a call, watch a demo, read a case study, AND reply with their timeline. Pick one ask. The more you ask for, the less likely any of it happens.
+
+---
+
+## Voice & Subject Lines
+
+> See `references/voice-and-subject-lines.md` for audience-specific calibration (C-suite, VP, mid-level, technical), subject line patterns that work, and patterns that kill opens.
+
+---
+
+## Follow-Up Strategy
+
+Cadence: Day 1 → Day 4 → Day 9 → Day 16 → Day 25 → Breakup Day 35. Gaps increase over time. Each follow-up must have a new angle (evidence, problem angle, insight, direct question, or reverse ask). Never "just check in." Each email stands alone.
+
+> See `references/follow-up-playbook.md` for full cadence templates, angle rotation guide, and breakup email examples.
+
+---
+
+## What to Avoid
+
+Patterns that mark you as non-human: "I hope this email finds you well," "I wanted to reach out because...," feature dumps in email 1, HTML templates, fake Re:/Fwd: subject lines, "Just checking in" follow-ups, opening with "My name is X and I work at Y," passive CTAs.
+
+See `references/frameworks.md` for the full anti-patterns list.
+
+---
+
+## Deliverability Basics
+
+Use a dedicated sending domain, configure SPF/DKIM/DMARC, warm up new domains over 4-6 weeks, send plain text, include unsubscribe mechanism, stay under 100-200 emails/day.
+
+See `references/deliverability-guide.md` for domain warmup schedule, SPF/DKIM setup, and spam trigger word list.
+
+---
+
+## Proactive Triggers
+
+Surface these without being asked:
+
+- **Email opens with "My name is" or "I'm reaching out because"** → rewrite the opener. These are dead-on-arrival openers. Flag and offer an alternative that leads with their world.
+- **First email is longer than 150 words** → almost certainly too long. Flag word count and offer to trim.
+- **No personalization beyond first name** → templated feel will hurt reply rates. Ask if there's a trigger or signal they can work with.
+- **Follow-up says "just checking in" or "circling back"** → useless follow-up. Ask what new angle or value they can bring to that touchpoint.
+- **HTML email template** → recommend plain text. Plain text emails have higher deliverability and look less like marketing blasts.
+- **CTA asks for 30-45 minute meeting in email 1** → too high-friction for cold outreach. Recommend a lower-commitment ask (a 15-minute call, or just a question to gauge interest first).
+
+---
+
+## Output Artifacts
+
+| When you ask for... | You get... |
+|---------------------|------------|
+| Write a cold email | First-touch email + 3 subject line variants + brief rationale for structure choices |
+| Build a sequence | 5-6 email sequence with send gaps, subject lines per email, and angle summary for each follow-up |
+| Critique my email | Line-by-line assessment + rewrite + explanation of each change |
+| Write follow-ups only | Follow-up emails 2-6 with unique angles per email + breakup email |
+| Analyze sequence performance | Diagnosis of where the sequence breaks (subject/body/CTA) + specific rewrite recommendations |
+
+---
+
+## Communication
+
+All output follows the structured communication standard:
+- **Bottom line first** — answer before explanation
+- **What + Why + How** — every finding has all three
+- **Actions have owners and deadlines** — no "we should consider"
+- **Confidence tagging** — 🟢 verified / 🟡 medium / 🔴 assumed
+
+---
+
+## Related Skills
+
+- **email-sequence**: For lifecycle and nurture emails to opted-in subscribers. Use email-sequence for onboarding flows, re-engagement campaigns, and automated drips. NOT for cold outreach — that's cold-email.
+- **copywriting**: For marketing page copy. Principles overlap, but cold email has different constraints — shorter, no CTAs like buttons, must feel personal.
+- **content-strategy**: For creating the content assets (case studies, guides) you reference in cold email follow-ups. Good follow-up sequences often link to content.
+- **marketing-strategy-pmm**: For positioning and ICP definition. If you don't know who you're targeting and why, cold email is the wrong tool to figure that out.