Activation Funnel

# Create a "Activation Funnel" AI Skill

I want you to help me set up a reusable AI skill that I can use in future conversations. Read the complete skill definition below, then help me install it.

## Complete Skill Definition

# Activation Funnel Expert

## Overview

A funnel is the single most useful diagnostic tool a growth or onboarding PM owns. It turns a fuzzy product story ("users drop off somewhere") into a numbered, actionable picture ("76% land, 41% start setup, 9% finish setup, 4% take the activation action -- the biggest drop is between start and finish setup at 32 percentage points").

This skill specifies funnel structures using **Dave McClure's AARRR** (Acquisition, Activation, Retention, Revenue, Referral) and its broader cousin **AAARRR** (which adds Awareness on the front), and analyzes them with a stdlib Python tool (`funnel_analyzer.py`). The tool ingests a JSON funnel definition (stages with counts), and outputs (a) stage-by-stage conversion and drop-off, (b) a Mermaid flowchart with conversion percentages on each arrow, (c) a bottleneck call-out for the largest absolute drop. It supports all six SHARED_OUTPUT_SCHEMA formats so the analysis travels into Jira, Linear, Confluence, Notion, or a PR.

The activation step is the centerpiece. Sean Ellis defined "activated user" as a user who has done the thing that, statistically, predicts retention. Slack's classic 2000-messages-per-team activation event, Facebook's "7 friends in 10 days", and Dropbox's "1 file in 1 folder on 1 device" are all activation definitions, not retention metrics. Pin the activation event before you optimize the funnel that leads to it.

### When to Use

- **New onboarding design** -- you are designing the user journey from signup to value and need to specify the funnel events.
- **Drop-off diagnosis** -- onboarding completion is flat but signups grow; where is the leak?
- **Activation metric definition** -- the team needs to pick the "aha" event that predicts long-term retention.
- **Cross-functional alignment** -- marketing optimizes acquisition, product optimizes activation, neither agrees on the funnel definition.
- **Quarterly business review** -- one canonical funnel chart drives the QBR conversation about growth.
- **A/B test design** -- a funnel makes the experiment's primary and counter-metric obvious.

### When NOT to Use

- For pre-product-market-fit discovery (use `discovery/brainstorm-ideas/`, `discovery/identify-assumptions/`; funnels presume a stable user journey).
- For pure top-of-funnel marketing-channel attribution (use marketing-side tools).
- For revenue-cohort retention analysis specifically (use the data-analytics domain; funnels capture single-flow conversion, cohorts capture time-based retention).
- When the team has not instrumented the events -- a funnel without telemetry is wishful thinking.

## Pirate Metrics framework (AARRR)

Dave McClure proposed Pirate Metrics in 2007 as a five-stage growth funnel:

| Stage | What it measures | Typical events |
|---|---|---|
| **Acquisition** | Users find you | Landing-page visit, ad click, organic search visit |
| **Activation** | First good experience | Signup, profile complete, "aha" event |
| **Retention** | They come back | D1, D7, D30 active; weekly active |
| **Revenue** | They pay | Trial-to-paid, upgrade, expansion |
| **Referral** | They tell others | Invite sent, invite accepted, share rate |

McClure's insight was that most teams obsess over Acquisition (the top) and Revenue (the bottom), while the leverage is usually in Activation and Retention. A 5-point improvement in activation flows through to retention, revenue, and referral; a 5-point improvement in acquisition often gets eaten by churn.

### AAARRR (Awareness-prefixed)

Some teams add **Awareness** at the front: how many people know your product exists at all? AAARRR is useful when the brand is new or the category is undefined; AARRR is fine when product-market fit is established.

| Stage | Question |
|---|---|
| **Awareness** | Do they know you exist? (impressions, mentions, branded search) |
| **Acquisition** | Do they visit you? (visits, signups-started) |
| **Activation** | Do they get value? (the aha event) |
| **Retention** | Do they come back? (D1, D7, D30) |
| **Revenue** | Do they pay? (trial-to-paid) |
| **Referral** | Do they bring friends? (invites, shares) |

## Defining activation: the "aha" event

Sean Ellis introduced the **activation-rate framework**: the activation event is the action that, statistically, separates users who retain from users who churn. Find it by:

1. Identify the cohort of users who are still active at D30 (or your retention horizon).
2. Look at what they did in their first session / first week that the churned cohort did not do.
3. The behavior with the highest correlation to D30 retention is the activation event candidate.

### Real activation events (publicly discussed)

| Product | Activation event |
|---|---|
| Slack | A team sends 2,000 messages |
| Facebook | A user adds 7 friends in 10 days |
| Dropbox | A user puts 1 file in 1 folder on 1 device |
| Airbnb (host) | A host books their first guest |
| Airbnb (guest) | A guest books their first trip |
| Notion | A user creates 3+ pages and invites 1+ collaborator |
| Spotify | A user listens to 25+ minutes in their first week |
| Duolingo | A user completes 1 lesson in 3 of their first 7 days |
| Twitter | A user follows 30+ accounts |
| HubSpot | A user adds 5 contacts and 2 deals |
| Pinterest | A user follows 5 boards and saves 1 pin |
| LinkedIn | A user adds 5 connections in their first week |
| Figma | A user creates a file and adds 2+ collaborators |
| Canva | A user creates a design and downloads or shares it |

The pattern: a **specific count + a specific time window + a specific action**. Vague "completed onboarding" is not an activation event -- it is an output. A good activation event is observable, instrumented, and predictive of long-term value.

## Funnel math

### Conversion rate

For each stage transition: `conversion[i] = users[i+1] / users[i]`

### Drop-off (absolute)

`drop[i] = users[i] - users[i+1]`

### Drop-off (rate)

`drop_rate[i] = 1 - conversion[i]`

### Cumulative conversion

`cumulative[i] = users[i] / users[0]`

The largest absolute drop is where the funnel leaks the most users. The largest *relative* drop (worst conversion rate) is where the stage is most broken. Both signals matter; this skill's tool surfaces both.

## Counter-metric pairing

Funnel optimization is famously easy to game. If you measure only conversion, you can boost it by lowering the bar at each stage:

- Drop email verification -> signup conversion goes up; fake-account problem goes up too.
- Auto-import data -> "activation" rate climbs; users feel nothing happened.
- Add a "skip" button -> setup completion climbs; D7 retention drops.

For every funnel stage, declare a **counter-metric** that must not degrade. The pair (conversion, counter-metric) is what gets reviewed -- not conversion alone.

| Funnel stage | Primary metric | Counter-metric |
|---|---|---|
| Acquisition | Signups / visitors | Quality signup rate (e.g., real-email %) |
| Activation | Activation rate | D7 retention of activated users |
| Retention | D30 retention | Engagement depth (events / active user) |
| Revenue | Trial-to-paid | First-month churn |
| Referral | Invite acceptance | Quality of referred user (do they activate?) |

## Leading vs lagging activation indicators

| Indicator | Timing | Use |
|---|---|---|
| **Leading** | Hours / days into use | Daily dashboard, on-call signal (e.g., "step 2 completion in first session") |
| **Activation** | First N days | The headline activation rate |
| **Lagging** | D30 retention of activated users | Quarterly truth check (is the activation event still predictive?) |

Leading indicators move first, so they are what the team optimizes. The activation rate is the headline. The lagging indicator audits whether the activation definition is still correct.

## Workflow

1. **Pick the framework.** AARRR for established product, AAARRR if the category is undefined.
2. **Define each stage as an event.** Each transition is `event A -> event B`. No vague stages.
3. **Pin the activation event.** Use Ellis's framework: find the behavior that separates retained from churned users.
4. **Instrument.** Telemetry must capture each stage event with a tenant / user / session id. Without instrumentation, the funnel is a guess.
5. **Pull stage counts** over a fixed window (week, month, or cohort). Note: a funnel for a cohort is more honest than a snapshot across cohorts.
6. **Run `funnel_analyzer.py`** to get conversion, drop-off, bottleneck, and the Mermaid diagram.
7. **Pair every stage with a counter-metric.** Document and review.
8. **Identify the bottleneck.** The largest absolute drop is usually where to invest. Use `prioritization-frameworks/` to rank fix-the-funnel projects.
9. **Wire the funnel into reporting.** Funnel deltas appear in weekly status (`status-update-generator/`) and quarterly review.

## Tools

| Tool | Purpose | Command |
|---|---|---|
| `funnel_analyzer.py` | Compute funnel conversions + drop-off + bottleneck; render in 6 formats | `python scripts/funnel_analyzer.py --input funnel.json --format markdown` |
| `funnel_analyzer.py --demo` | Inspect a worked SaaS activation funnel | `python scripts/funnel_analyzer.py --demo --format mermaid` |

## Troubleshooting

| Symptom | Likely Cause | Resolution |
|---|---|---|
| Funnel conversion looks great but D30 retention is flat | Activation event is too easy / not predictive of retention | Re-run Ellis's framework on the latest cohort; pick a harder + more predictive event |
| Stage counts do not add up; later stages exceed earlier ones | Multi-session or multi-tenant double-counting; events are not properly scoped | Constrain analysis to a single-cohort, single-user funnel; deduplicate by user_id; check event timestamps |
| Team optimizes acquisition; nothing improves downstream | The bottleneck is downstream, not at the top | Run the tool, look at absolute drop sizes, redirect investment to the largest drop stage |
| Activation rate jumps after a UX change but engagement drops | Counter-metric not paired; the funnel is being gamed | Add a counter-metric per stage; review the pair, not the conversion alone |
| Funnel looks different every week | Snapshot funnel across mixed cohorts | Switch to cohort-based funnel: pick a signup cohort, follow it through stages over the same N days |
| Funnel only covers the happy path | Edge cases and re-entries not modeled | List the 3-5 most common alternative paths; instrument them as parallel funnels or recovery loops |
| Stakeholders ignore the funnel chart | Chart has 12 stages and reads as a wall of numbers | Compress to 4-6 stages; the deeper drill-down lives in a dashboard, not the headline funnel |

## Success Criteria

- The funnel has 4-7 stages (5 is the sweet spot). Each stage is a specific event.
- The activation event is specific (count + window + action) and statistically predictive of retention.
- Every stage has a paired counter-metric documented.
- The analysis is cohort-based, not snapshot-based.
- The largest absolute drop is identified and assigned an owner.
- The funnel is reviewed weekly during build, monthly during steady-state.
- A new hire can name the activation event and the current funnel's biggest leak within their first week.

## Scope & Limitations

**In Scope:**
- Funnel definition (events, stages, transitions) using AARRR / AAARRR frameworks
- Conversion + drop-off math, bottleneck detection
- Mermaid flowchart rendering with conversion percentages on each transition
- Activation event selection guidance (Sean Ellis framework)
- Counter-metric pairing per stage
- Cohort vs snapshot funnel distinction
- All 6 SHARED_OUTPUT_SCHEMA formats for the analysis output

**Out of Scope:**
- Pulling raw event data from analytics tools -- input is JSON; use Amplitude/Mixpanel/PostHog/Looker to produce the JSON
- Statistical significance testing on funnel deltas (use `discovery/brainstorm-experiments/` for experiment design; data-analytics domain for stats)
- Cohort-retention analysis (a different kind of analysis -- see data-analytics)
- Channel-attribution modeling (marketing-side tools)
- Building the actual UX or A/B test (this skill specifies the funnel and the leak; engineering builds the fix)
- Forecasting (this is descriptive analysis, not predictive modeling)

**Important Caveats:**
- A funnel implies a linear flow. Real products have branches, re-entries, and recovery loops. Use the funnel as the headline; complement it with branched analysis when needed.
- Snapshot funnels mix cohorts and lie. Always specify the cohort window in the JSON input.
- Conversion improvements at top stages amplify downstream, so they look large in absolute users; this can mislead investment decisions away from genuinely-broken downstream stages. Look at *both* absolute and relative drop.
- An activation event that worked 12 months ago may no longer be predictive. Re-validate against the latest retention cohorts every 1-2 quarters.

## Integration Points

| Integration | Direction | Description |
|---|---|---|
| `north-star-metric/` | Pairs with | Activation rate is often the NSM or a top input metric in the NSM tree |
| `brainstorm-okrs/` | Feeds into | Funnel-stage targets become KRs (e.g., "improve activation from 28% to 36%") |
| `prioritization-frameworks/` | Feeds into | Fix-the-funnel projects ranked by RICE / weighted-score |
| `discovery/brainstorm-experiments/` | Pairs with | Each funnel leak suggests testable experiments to plug it |
| `discovery/identify-assumptions/` | Pairs with | "Users will complete step 3 if we shorten it" is an assumption to validate |
| `status-update-generator/` | Feeds into | Weekly funnel deltas appear in Highlights / Risks |
| `outcome-roadmap/` | Pairs with | Roadmap items justify themselves by which funnel stage they target |
| `cycle-time-analyzer/` | Pairs with | Cycle time to fix funnel leaks is part of flow analysis |
| `data-analytics/` (domain) | Pairs with | Telemetry instrumentation; cohort analysis; stat sig |

## Tool Reference

### funnel_analyzer.py

Analyzes a funnel from a JSON definition. Computes per-stage conversion + absolute and relative drop-off + bottleneck. Renders in 6 formats. Mermaid output uses `flowchart LR` with conversion % on each arrow.

| Flag | Type | Default | Description |
|---|---|---|---|
| `--input` | string | (required unless `--demo`) | Path to JSON funnel definition |
| `--demo` | flag | false | Use a built-in SaaS activation funnel |
| `--format` | choice | markdown | Output: json, markdown, mermaid, confluence, notion, linear |
| `--output` | string | stdout | Output file path |
| `--name` | string | (from input) | Override funnel name |
| `--cohort` | string | (from input) | Override cohort label |

### Input JSON shape

```json
{
  "name": "SaaS Free Trial Activation",
  "cohort": "Cohort: signups in week of 2026-05-04",
  "framework": "AARRR",
  "stages": [
    {"name": "Landing visit", "stage": "acquisition", "count": 10000, "counter_metric": "Bounce rate < 60%"},
    {"name": "Signup started", "stage": "acquisition", "count": 2400, "counter_metric": "Signup-to-real-email > 90%"},
    {"name": "Email verified", "stage": "acquisition", "count": 1800, "counter_metric": null},
    {"name": "First workspace created", "stage": "activation", "count": 1100, "counter_metric": null},
    {"name": "Aha event: 3 docs created + 1 collaborator", "stage": "activation", "count": 410, "counter_metric": "D7 retention of activated > 55%"},
    {"name": "D30 retention", "stage": "retention", "count": 290, "counter_metric": "Engagement events/day > 4"},
    {"name": "Paid", "stage": "revenue", "count": 180, "counter_metric": "First-month churn < 8%"}
  ]
}
```

### Mermaid output sample

```mermaid
flowchart LR
    S0["Landing visit<br/>10000"] -->|24.0%| S1["Signup started<br/>2400"]
    S1 -->|75.0%| S2["Email verified<br/>1800"]
    S2 -->|61.1%| S3["First workspace created<br/>1100"]
    S3 -->|37.3%| S4["Aha event<br/>410"]
    S4 -->|70.7%| S5["D30 retention<br/>290"]
    S5 -->|62.1%| S6["Paid<br/>180"]
```

The tool flags the largest absolute drop with a callout in the rendered output. In the demo above, the biggest leak in absolute users is at Landing -> Signup (7600 users), but the biggest *rate* drop is at First workspace -> Aha (37.3% conversion). Both get surfaced.

## References

- `references/pirate-metrics-deep-dive.md` -- McClure's AARRR + AAARRR, Andrew Chen funnel mechanics, Reforge growth model, NSM-funnel linkage
- `references/activation-aha-moment-patterns.md` -- Ellis's framework + 12 worked activation-event examples (Slack, FB, Dropbox, Airbnb, Notion, Spotify, Duolingo, Twitter, HubSpot, Pinterest, LinkedIn, Figma)
- `assets/funnel_design_canvas.md` -- Workshop canvas for defining the funnel
- `assets/activation_metric_worksheet.md` -- Worksheet for picking the activation event
- `assets/sample_funnel.json` -- A working JSON example matching the tool input

---

## What I Need You to Do

First, detect which platform I'm using (Claude.ai, ChatGPT, etc.) and follow the matching instructions below.

### If I'm on Claude.ai:

Walk me through these exact steps:

1. **Create the Project:** Tell me to go to **claude.ai > Projects > Create project** and name it **"Activation Funnel"**

2. **Add Project Knowledge:** Give me the COMPLETE skill definition above as a single copyable text block inside a code fence. Tell me to click **"Add content" > "Add text content"** inside the project, then paste that entire block. Do NOT say "paste from above" -- give me the actual text to copy right there.

3. **Set Custom Instructions:** Tell me to open project settings and paste this exact instruction:
   "You are an expert Activation Funnel in the Project Management domain. Use the project knowledge as your expertise. Follow the workflows, frameworks, and templates defined there. Always provide specific, actionable output."

4. **Test It:** Give me a specific sample prompt I can use inside the new project to verify it works. Pick a real task from the skill's workflows.

### If I'm on ChatGPT:

Walk me through these exact steps:

1. **Create a Custom GPT:** Tell me to go to **chatgpt.com > Explore GPTs > Create**
2. **Configure it:**
   - Name: **"Activation Funnel"**
   - Description: "Design and analyze activation funnels (AARRR / AAARRR Pirate Metrics) with conversion + drop-off math, bottleneck detection, and Mermaid funnel diagrams. Includes a stdlib Python tool that emits all 6 shared PM output formats."
   - Instructions: Give me the COMPLETE skill definition above as a single copyable text block inside a code fence to paste into the Instructions field. Do NOT say "paste from above."
3. **Test It:** Give me a sample prompt to verify it works.

### If I'm on another platform:
Ask which tool I'm using and adapt the instructions accordingly.

## Important
- Always provide the full skill text in a ready-to-copy code block -- never tell me to "scroll up" or "copy from above"
- Keep the setup steps simple and numbered
- After setup, test it with me using a real workflow from the skill

Source: https://github.com/borghei/Claude-Skills/tree/main/project-management/execution/activation-funnel/SKILL.md