app-growth-design 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 bixxter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,146 @@
+# app-growth-design
+
+A Claude Code skill for the decisions that actually move an app: **onboarding, paywalls, pricing, retention, gamification, growth loops and screen-level craft.**
+
+It is not another "be a helpful product expert" prompt. It is a knowledge base — 5.7 hours of teardowns from [Tim Gabe's YouTube channel](https://www.youtube.com/@TimGabe) compressed into six playbooks where every non-obvious claim carries a `[NN]` marker back to the video it came from, and every case study keeps its numbers.
+
+```bash
+npx github:bixxter/app-growth-design
+```
+
+That's it. Pick user-wide or project-only, restart Claude Code, and the skill loads itself whenever you're working on one of those problems.
+
+---
+
+## What changes when it's installed
+
+Without it, ask Claude *"my paywall converts at 2%, what do I test first?"* and you get sensible, generic advice: try annual vs monthly, test your copy, add social proof.
+
+With it, the same question routes into `monetization-paywalls.md` and comes back with an ordering that has evidence attached:
+
+> Structure out-tests price, always. Ranked LTV uplift across the corpus: locale 62.3% > trial structure 59.6% > plan duration 58.7% > plan count 57.1% > **price 45.5%** > visuals 34.6%. Adding a free trial to a *weekly* plan took 12-month LTV from $7.40 to $54.50 (+636%) — no price test does that. `[06]`
+>
+> But first check which layer you're on: 57.7% of new apps never cross $1,000 in revenue. Below the top decile this isn't a monetization problem. `[06]`
+
+Same for the rest:
+
+| You're working on | It routes to | Sample of what's in there |
+|---|---|---|
+| First-run flow, quiz vs. short flow, time-to-value, activation | `onboarding-activation.md` | Granola ships value in 2 screens ($1.5B); Cal AI runs a 20+ step quiz ($35M year one); Noom runs 113 screens. Length is only justified if it buys visible personalization or a buyer filter. |
+| Paywall layout, trials, plan count, price tiers | `monetization-paywalls.md` | Weekly plans convert 1.7–7.4× better than annual at every price tier. 82–89% of trial starts happen on install day. |
+| Streaks, leaderboards, badges, churn, reward ceremonies | `retention-gamification.md` | A 35-intervention meta-analysis: gamification lifts autonomy (g=0.638) and relatedness (g=1.776) but barely touches competence (g=0.277). Depth is non-monotonic — past a point the fix is cutting. |
+| *Why* users behave this way — identity, dopamine, loss aversion | `behavioral-psychology.md` | Build Mirror → Label → Flex. Exit question: if a user left today, what would they rebuild from scratch? "Nothing much" = no moat. |
+| Positioning vs. an incumbent, moats, share loops, landing pages | `growth-marketing.md` | Design the share *artifact*, not the share button. Fuse share with invite at a 1-friend threshold. Attachment before virality. |
+| Type scale, spacing, color budget, motion, microcopy | `design-craft.md` | The countable craft checklist, the subtraction pass, the five-criterion screen audit. |
+
+**243 named products** are indexed with what each one exemplifies, so the model can reach for a real citation instead of inventing a plausible one.
+
+---
+
+## Install
+
+```bash
+# interactive — asks user-wide or project-only
+npx github:bixxter/app-growth-design
+
+# non-interactive
+npx github:bixxter/app-growth-design --user      # ~/.claude/skills/app-growth-design
+npx github:bixxter/app-growth-design --project   # ./.claude/skills/app-growth-design
+npx github:bixxter/app-growth-design --dir ~/some/skills
+
+# later
+npx github:bixxter/app-growth-design --force       # update in place
+npx github:bixxter/app-growth-design --uninstall
+```
+
+Node 18+. No dependencies — the installer is one file that copies `skill/` into your skills directory and nothing else.
+
+Prefer to do it by hand? `cp -r skill ~/.claude/skills/app-growth-design`. It works in anything that reads the [Agent Skills](https://code.claude.com/docs/en/skills) format.
+
+---
+
+## How it was built
+
+The short version. The long version — every decision and the two things that went wrong — is in **[docs/PROCESS.md](docs/PROCESS.md)**.
+
+The problem with turning a YouTube channel into agent knowledge is that the naive path fails twice. Dumping raw captions gives you 220k words of rolling-window duplicates, most of it filler. And a design channel is the worst possible case for captions alone: the man is *pointing at a screen*. "Look at how they did this" is the entire claim, and the audio carries none of it.
+
+So the pipeline is built around one idea: **the frames are not decoration, they are the missing half of the content.**
+
+```
+30 videos (5.7 h)
+      │
+  1 ──┤ yt-dlp: captions only, 6-wide          → 2.6 MB VTT / 220,498 words
+      │
+  2 ──┤ dedupe rolling captions, regroup       →   49,629 words, ~30s blocks
+      │   into ~30s timestamped blocks             (4.4× smaller, addressable)
+      │
+  3 ──┤ yt-dlp: 480p video, 3-wide             → 510 MB, deleted after stage 4
+      │
+  4 ──┤ ONE AGENT PER VIDEO, in parallel:      →   30 notes / 118,660 words
+      │   read transcript → find the moments        1,161 frames extracted
+      │   where meaning is on screen, not in        476 described in-line
+      │   the audio → ffmpeg those timestamps
+      │   → actually LOOK at the frames →
+      │   write a structured note
+      │      ↓
+      │   second agent re-reads each note against the transcript and
+      │   fixes what's missing — unresolved "this screen", dropped numbers,
+      │   verbatim bloat, vague filler rules
+      │
+  5 ──┤ SIX AGENTS, one per theme, each        →    6 playbooks / 55,241 words
+      │   reading across all 30 notes:              + SKILL.md router (2,378 words)
+      │   merge, resolve contradictions,
+      │   keep every number and product name
+```
+
+Note what happens to the word count at stage 4: the notes come out **more than twice the size of the speech**. That's the whole point — 1,161 screenshots put back what the captions lost.
+
+Three details that turned out to matter more than expected:
+
+- **Captions lag the screen by a beat.** Frames get extracted 2–4 seconds *after* he starts describing something, or you capture the previous slide.
+- **The verify pass is where quality comes from.** The single most common defect was a note that still said "the example shown here" — a reference the downstream agent can't use. Verification agents re-extract the frame, look at it, and write in what was actually there.
+- **`[NN]` markers everywhere.** Every claim in the playbooks points back at a source video. That's what makes the skill arguable rather than oracular — you can check it, and so can the model.
+
+---
+
+## Rebuild it for a different channel
+
+Everything needed is in [`pipeline/`](pipeline/), and the whole thing is channel-agnostic — swap `pipeline/manifest.tsv` for your own list of videos and re-run. See [pipeline/README.md](pipeline/README.md) for the exact commands.
+
+```
+pipeline/
+├── manifest.tsv               num ⇥ video_id ⇥ title ⇥ duration_s — the only input you change
+├── 1-fetch-subs.sh            captions, 6 parallel
+├── 2-clean-vtt.py             dedupe + regroup into ~30s timestamped blocks
+├── 3-fetch-video.sh           480p, 3 parallel
+├── 3b-retry-video.sh          sweep for what YouTube throttled
+├── 4-enrich.workflow.js       one agent per video: frames + note, then verify
+├── 5-synthesize.workflow.js   six agents: notes → playbooks → SKILL.md
+└── recover.workflow.js        the lean rewrite of stage 4, after the first run
+                               burned itself out (see docs/PROCESS.md)
+```
+
+Stages 4–5 are [Claude Code Workflow](https://code.claude.com/docs/en/claude-code) scripts — deterministic orchestration over parallel subagents. Stages 1–3 need `yt-dlp` and `ffmpeg`.
+
+---
+
+## Honesty section
+
+**This is one practitioner's opinionated view, not settled fact.** Nearly every mechanic in the corpus is asserted from survivorship-selected case studies. There are essentially no before/after deltas attributable to a specific change. Treat the cases that carry real numbers as evidence and the rest as hypotheses worth testing.
+
+**The corpus contradicts itself**, and the playbooks say so rather than papering over it — short vs. long onboarding, friction-removal vs. friction-as-amplifier, design-as-moat vs. design-is-not-the-moat. Each reference file ends with **Anti-patterns**, **Contradictions** and **Caveats**. Read them before advising anyone.
+
+**Agency promos are flagged.** Tim runs a design agency and pitches it 2–4 times per video; several case studies are his own unaudited client work. Those segments are marked as promotional. Use the mechanics, never the implied results.
+
+---
+
+## Attribution & licensing
+
+All the underlying insight belongs to **[Tim Gabe](https://www.youtube.com/@TimGabe)** — if this is useful to you, go watch the source videos. Every `[NN]` marker in the skill links to one.
+
+This repo ships **structured, synthesized notes, not republished transcripts.** No captions, no video, no screenshots are included here; the pipeline that produces them from public YouTube content is included so you can reproduce the work yourself.
+
+The pipeline code is MIT ([LICENSE](LICENSE)). The distilled playbooks in `skill/` are commentary on publicly published material — use them, and keep the attribution.
+
+Not affiliated with, endorsed by, or reviewed by Tim Gabe.

package/bin/install.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+// Installs the app-growth-design skill into a Claude Code skills directory.
+// Zero dependencies, Node 18+. Copies files; it never writes outside the chosen target.
+import { createInterface } from 'node:readline/promises'
+import { fileURLToPath } from 'node:url'
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import process from 'node:process'
+
+const SKILL = 'app-growth-design'
+const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const SRC = path.join(PKG_ROOT, 'skill')
+
+const tty = process.stdout.isTTY && !process.env.NO_COLOR
+const c = (code, s) => (tty ? `\x1b[${code}m${s}\x1b[0m` : s)
+const bold = s => c('1', s)
+const dim = s => c('2', s)
+const green = s => c('32', s)
+const cyan = s => c('36', s)
+const red = s => c('31', s)
+
+const HELP = `
+${bold('app-growth-design')} — install the skill into Claude Code
+
+  ${cyan('npx github:bixxter/app-growth-design')}            pick a target interactively
+  ${cyan('npx github:bixxter/app-growth-design --user')}     ~/.claude/skills/${SKILL}
+  ${cyan('npx github:bixxter/app-growth-design --project')}  ./.claude/skills/${SKILL}
+
+Options
+  --user, --global   install for every project on this machine (default)
+  --project          install into the current project only
+  --dir <path>       install into a specific skills directory
+  --force            overwrite an existing install without asking
+  --yes, -y          never prompt; take the defaults
+  --uninstall        remove a previously installed copy
+  -h, --help         this text
+`
+
+function parseArgs(argv) {
+  const o = { target: null, dir: null, force: false, yes: false, uninstall: false, help: false }
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]
+    if (a === '--user' || a === '--global') o.target = 'user'
+    else if (a === '--project' || a === '--local') o.target = 'project'
+    else if (a === '--dir') { o.dir = argv[++i]; o.target = 'custom' }
+    else if (a === '--force' || a === '-f') o.force = true
+    else if (a === '--yes' || a === '-y') o.yes = true
+    else if (a === '--uninstall' || a === '--remove') o.uninstall = true
+    else if (a === '--help' || a === '-h') o.help = true
+    else if (a.startsWith('-')) { console.error(red(`Unknown option: ${a}`)); process.exit(2) }
+  }
+  if (o.dir && !o.dir.trim()) { console.error(red('--dir needs a path')); process.exit(2) }
+  return o
+}
+
+const exists = async p => !!(await fs.stat(p).catch(() => null))
+
+async function copyDir(src, dest) {
+  await fs.mkdir(dest, { recursive: true })
+  let files = 0
+  for (const entry of await fs.readdir(src, { withFileTypes: true })) {
+    if (entry.name === '.DS_Store') continue
+    const from = path.join(src, entry.name)
+    const to = path.join(dest, entry.name)
+    if (entry.isDirectory()) files += await copyDir(from, to)
+    else { await fs.copyFile(from, to); files++ }
+  }
+  return files
+}
+
+async function ask(question, fallback) {
+  if (!process.stdin.isTTY) return fallback
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+  try { return (await rl.question(question)).trim() } finally { rl.close() }
+}
+
+async function resolveTarget(opts) {
+  const userDir = path.join(os.homedir(), '.claude', 'skills')
+  const projectDir = path.join(process.cwd(), '.claude', 'skills')
+  if (opts.target === 'custom') return path.resolve(opts.dir)
+  if (opts.target === 'user') return userDir
+  if (opts.target === 'project') return projectDir
+  if (opts.yes || !process.stdin.isTTY) return userDir
+
+  console.log(`\n  Where should ${bold(SKILL)} go?\n`)
+  console.log(`    ${bold('1')}  ${userDir}   ${dim('(all projects — default)')}`)
+  console.log(`    ${bold('2')}  ${projectDir}   ${dim('(this project only)')}\n`)
+  const answer = await ask('  1 or 2: ', '1')
+  return answer === '2' ? projectDir : userDir
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2))
+  if (opts.help) { console.log(HELP); return }
+
+  if (!(await exists(SRC))) {
+    console.error(red(`Cannot find the skill source at ${SRC}`))
+    process.exit(1)
+  }
+
+  const skillsDir = await resolveTarget(opts)
+  const dest = path.join(skillsDir, SKILL)
+
+  if (opts.uninstall) {
+    if (!(await exists(dest))) { console.log(dim(`\n  Nothing at ${dest}\n`)); return }
+    await fs.rm(dest, { recursive: true, force: true })
+    console.log(`\n  ${green('Removed')} ${dest}\n`)
+    return
+  }
+
+  if (await exists(dest)) {
+    if (!opts.force && !opts.yes) {
+      const answer = await ask(`\n  ${dest} already exists. Overwrite? ${dim('[Y/n]')} `, 'y')
+      if (answer && !/^y(es)?$/i.test(answer)) { console.log(dim('\n  Cancelled.\n')); return }
+    }
+    await fs.rm(dest, { recursive: true, force: true })
+  }
+
+  const files = await copyDir(SRC, dest)
+
+  console.log(`
+  ${green('Installed')} ${bold(SKILL)} ${dim(`(${files} files)`)}
+  ${dim('→')} ${dest}
+
+  ${bold('Use it')} — restart Claude Code, then just describe the problem:
+
+    ${cyan('"audit my onboarding flow"')}
+    ${cyan('"my paywall converts at 2%, what should I test first?"')}
+    ${cyan('"design a streak that does not backfire"')}
+
+  The skill loads itself when the topic matches. To force it: ${cyan(`/${SKILL}`)}
+  ${dim('Uninstall: npx github:bixxter/app-growth-design --uninstall')}
+`)
+}
+
+main().catch(err => {
+  console.error(red(`\n  Install failed: ${err.message}\n`))
+  process.exit(1)
+})

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "app-growth-design",
+  "version": "1.0.0",
+  "description": "Claude Code skill: app onboarding, paywalls, pricing, retention, gamification and growth — distilled from 30 Tim Gabe teardowns into six source-marked playbooks.",
+  "type": "module",
+  "bin": {
+    "app-growth-design": "bin/install.mjs"
+  },
+  "files": [
+    "bin",
+    "skill",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "install-skill": "node bin/install.mjs"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "claude-skill",
+    "agent-skill",
+    "ai-agent",
+    "app-growth",
+    "onboarding",
+    "paywall",
+    "pricing",
+    "retention",
+    "gamification",
+    "product-design",
+    "ux"
+  ],
+  "author": "bixxter",
+  "license": "MIT",
+  "homepage": "https://github.com/bixxter/app-growth-design#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bixxter/app-growth-design.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bixxter/app-growth-design/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/skill/SKILL.md

@@ -0,0 +1,188 @@
+---
+name: app-growth-design
+description: Use when designing or auditing app onboarding and activation flows, paywalls and free-trial structure, subscription pricing and plan packaging, retention and gamification mechanics (streaks, leaderboards, badges, reward ceremonies), share and referral loops, landing-page conversion, screen-level UI/UX craft, or when positioning an app against an incumbent and planning app growth — routes to a distilled knowledge base of 30 Tim Gabe app teardowns with named case studies and source-marked rules.
+---
+
+# App Growth & Design Playbook
+
+## What this is
+
+A knowledge base distilled from the 30 most recent videos on **Tim Gabe's YouTube channel**
+(https://www.youtube.com/@TimGabe), covering app psychology, onboarding, paywalls and pricing,
+retention and gamification, growth and positioning, and design craft. The six thematic playbooks in
+`references/` hold the depth; the `[NN]` markers throughout resolve against the **Source index** at
+the bottom of this file, which links each number back to the original video.
+
+**This is one practitioner's opinionated view, not settled fact.** Almost every mechanic in the corpus
+is asserted from survivorship-selected case studies, not measured — there are essentially no
+before/after deltas attributable to a specific mechanic. Prefer cases that carry real numbers, and
+present the rest as hypotheses to test. Each reference file ends with **Anti-patterns**,
+**Contradictions** and **Caveats** sections: read them before advising, because the corpus contradicts
+itself in several load-bearing places (short vs. long onboarding, friction removal vs. friction as
+amplifier, design-as-moat vs. design-is-not-the-moat).
+
+**Agency promos are flagged.** Tim runs a design agency (Zipsa / Zipzap) and pitches "free design
+strategy calls" 2–4 times per video; several case studies (Freecash, Game Blazers, SolCard, Spark) are
+his own unaudited client work. The playbooks mark those segments as promotional. Use the mechanics,
+never the implied results.
+
+## How to use
+
+Route by the situation, then cite the `[NN]` source marker back to the video it came from.
+
+| The user is working on… | Read |
+|---|---|
+| First-run flow, permission screens, quiz-vs-short-flow decision, time-to-value, aha moment, activation | `references/onboarding-activation.md` |
+| Paywall layout, trial structure, plan count and duration, price tiers, coin/credit economies, converting existing free users | `references/monetization-paywalls.md` |
+| Streaks, leaderboards, badges, challenges, reward ceremonies, habit loops, churn, done-states | `references/retention-gamification.md` |
+| *Why* users behave this way — identity, dopamine, loss aversion, social proof, sunk cost — plus ethical and regulatory exposure | `references/behavioral-psychology.md` |
+| Screen-level craft: type scale, spacing, color budget, motion, microcopy, emotional feedback, design review | `references/design-craft.md` |
+| Positioning against an incumbent, moat selection, growth loops, share artifacts, landing pages, AI/agent disruption | `references/growth-marketing.md` |
+| Finding a citable example fast | **Case index** below → then the named reference file |
+
+Most questions touch two files (e.g. onboarding + monetization for session-zero conversion). Read both
+rather than guessing across the gap.
+
+## Highest-leverage rules
+
+The rules across the whole corpus most likely to change a founder's decision.
+
+1. **Diagnose the layer before optimizing it.** 57.7% of new apps never cross $1,000 in revenue; below
+   the top decile "this isn't a monetization problem" — it's distribution or product. Paywall tactics
+   that work at the 95th percentile don't apply at the 40th. `[06]`
+2. **Optimize time-to-tangible-value, not screen count.** Granola ships value in 2 screens ($1.5B);
+   Cal AI runs a 20+ step quiz ($35M year one); Noom runs 113 screens ($3.7B). Length is only justified
+   if it buys (a) personalization that is *visible on the first post-onboarding screen*, or (b) a buyer
+   filter. If it buys neither, it is tax and it shows up in D3. `[05]`
+3. **Trust, not brevity, is the binding constraint in session zero.** 82–89% of trial starts happen on
+   install day and never recover after day 7 — which is why a 28-screen flow can beat a 3-screen one.
+   Top-decile apps' edge is at *trial start* (20.3% vs 6.2% median), not trial→paid. `[06]`
+4. **Commitment size beats total cost.** Weekly plans convert **1.7–7.4x better than annual at every
+   price tier**, despite being a far worse deal. Annual revenue is deferred, not lost. `[06]`
+5. **Structure out-tests price, always.** Ranked LTV uplift: locale 62.3% > trial structure 59.6% >
+   plan duration 58.7% > plan count 57.1% > price 45.5% > visuals 34.6%. Adding a free trial to a weekly
+   plan took 12-month LTV from $7.40 to $54.50 (**+636%**) — no price test does that. `[06]`
+6. **Transparency is a conversion mechanism, not a softness tax.** Blinkist added one "how your free
+   trial works" timeline with an absolute charge date and tap-by-tap cancel steps: **+23% conversion,
+   −55% complaints, zero churn change.** `[06]` `[23]`
+7. **Repackage before you rebuild.** Every lift in the SaaS-tricks corpus came from copy, packaging or
+   visibility — no new features, no price changes: Mobbin +35% free-to-paid from stamping PRO labels on
+   already-locked content; Moonly +39% from removing the trial from the monthly plan. `[23]`
+8. **Fire the ask at the emotional peak, never at a session boundary.** ReelShort paywalls the
+   cliffhanger so paying reads as *relief*; Starcrossed paywalls immediately before the reveal. The
+   common failure is showing paywalls and tutorials while users are confused. `[08]` `[01]` `[15]`
+9. **Deliver rewards as gifts, not receipts.** Anticipation → weighted reveal → afterglow. Most apps
+   ship stage two only. N results delivered at once = one dopamine event; revealed one at a time = N.
+   Spotify Wrapped hit 200M users in 24 hours because it is a ceremony, not a report. `[10]`
+10. **A leaderboard is a surface; social comparison is the engine.** Diagnostic: does a user leave
+    believing a *specific named person* is beating them? Winnability predicts motivation — localize the
+    cohort (Strava segments, ~5–12 visible rivals) instead of adding rows to a global board. `[03]` `[07]`
+11. **Points, badges and leaderboards are the scoreboard, not the game.** A 35-intervention
+    meta-analysis: gamification lifts autonomy (g=0.638) and relatedness (g=1.776) but barely touches
+    **competence** (g=0.277) — the need tied to long-term motivation. And depth is non-monotonic: if
+    you're running streaks + points + badges + challenges + leaderboards at once you are past the peak,
+    and the fix is cutting. LinkedIn, Foursquare and Google News all retreated from badges. `[07]`
+12. **Identity is the only retention nobody churns out of.** Build Mirror → Label → Flex; ship one
+    identity metric computed from data users can't get elsewhere (Whoop Age). The exit question:
+    *if a user left today, what would they have to rebuild from scratch?* "Nothing much" = no moat.
+    `[01]` `[11]` `[13]`
+13. **Design the share artifact, not the share button — and sequence attachment before virality.**
+    Fuse share with invite at a **1-friend** threshold (Airbuds), pre-render for the destination
+    (Duolingo's square card), make it travel as plain text (Wordle). A referral program bolted onto a
+    product with no flex "does zero." `[01]` `[17]`
+14. **Count exit ramps, not screens — but friction has a sweet spot, not a floor.** Netflix's mobile
+    flow has ≥6 decision points before playback; ReelShort's player has none (35.7 vs 24.8 min/day).
+    Yet too little friction and users are never guided to value. Remove unnecessary UI; don't bury
+    controls four levels deep. `[08]` `[16]` `[15]`
+15. **Craft is arithmetic before it is taste.** Grade screens on copywriting → visuals → colors → fonts
+    → spacing. Seniors use ~4 font sizes / 2 weights, spacing divisible by 8, a 60/30/10
+    neutral/complementary/brand color budget, outer radius = inner radius + padding, and exactly one
+    saturated CTA (18,000+ landing pages: 1 CTA 13.5%, 2 CTAs 11.9%, 3 CTAs 10.5%). `[30]` `[12]` `[27]`
+
+Two cross-cutting cautions: **shame is a retention mechanic that poisons your data** (MacroFactor's
+no-streak, no-red-alert design is a data-quality argument, not a kindness one) `[02]`, and several
+mechanics here carry live legal exposure — Robinhood paid $7.5M over trade confetti, Nevada sued
+Snapchat over streaks, and the EU Digital Fairness Act draft names streaks and infinite scroll
+explicitly `[07]` `[10]`.
+
+## Case index
+
+| Product | Exemplifies | Notes |
+|---|---|---|
+| Cal AI | Long personalization quiz that earns its length; camera-as-homepage; 3 dedicated trial screens | `[05]` `[06]` `[02]` |
+| Granola | The 2-screen pole: permission-only onboarding, value inside an already-scheduled meeting | `[05]` |
+| Noom | 113-screen progressive commitment before the paywall | `[05]` |
+| Blinkist | The honest trial paywall (timeline, absolute date, cancel steps) | `[06]` `[23]` |
+| Mobbin / Moonly / Headspace / Busuu / Slopes | Packaging-only conversion lifts with no product or price change | `[23]` |
+| Yazio / Lose It! | Structure-first paywalls; outcome promise above the plan grid | `[06]` |
+| Uber | Certainty effect (single price beats a range); the reference *ending* design | `[23]` `[19]` |
+| ReelShort | Graduated gate (attention → effort → money); chromeless player; anti-calculator pricing (dark pattern) | `[08]` |
+| Tinder | Aha in <60s; double-blind matching removes emotional risk; contextual upsells after attachment | `[21]` |
+| Netflix | Skip Intro, 1,300 micro-genres, "97% Match"; also the exit-ramp counter-example | `[16]` `[08]` |
+| Spotify Wrapped / Discover Weekly | Gated data as ceremony; Trojan Horse — complex tech in a familiar container | `[10]` `[17]` |
+| Strava | Hyper-local segment cohorts, kudos, feed of *other people*; identity moat | `[03]` `[07]` `[09]` `[11]` |
+| Peloton | Live leaderboard + name callouts; uncapped milestone wall with visible unearned rungs | `[03]` `[07]` `[09]` |
+| Duolingo | Emotional feedback layer, streak wrapped in agency, pre-rendered share card | `[26]` `[07]` `[10]` |
+| Freecash / Game Blazers | Accumulating-asset streaks; case-spinner and pack-opening ceremonies *(agency clients — no independent data)* | `[09]` `[14]` `[10]` |
+| Finch | Nested variable-ratio rewards that never resolve | `[09]` |
+| Habitica | The over-gamification failure case (overload zone) | `[07]` |
+| LinkedIn / Foursquare / Google News | Three platform retreats from points-badges-leaderboards | `[07]` |
+| Snapchat streaks / Robinhood confetti | Potency vs. regulatory exposure | `[07]` `[10]` |
+| Whoop | The identity metric (Whoop Age, weekly Pace of Aging) | `[11]` |
+| Oura / Midjourney / Ramp vs Brex | Accumulating per-user intelligence as the moat; the exit question | `[13]` |
+| MacroFactor | No-shame design as a data-quality moat | `[02]` |
+| Tiimo | Niche depth by changing the interface's *shape*, not its theme | `[02]` |
+| Ladder | Cohort calendar; the acquire-mechanic vs retain-mechanic split | `[02]` |
+| Carrot Weather / Day One / Forest | Indie beats incumbent by conceding the commodity layer and winning the envelope | `[04]` |
+| Raycast | Distribution as a design problem; the feature-unlocks-feature growth loop | `[28]` |
+| Starcrossed / 16 Personalities / Airbuds / Wordle | The identity stack: Mirror → Label → Flex | `[01]` |
+| Apple | Habit training with no tutorial; ceremony engineered into packaging | `[18]` `[10]` |
+| Ahead | Peak–end done without guilt mechanics; the self-constructing personalized brief | `[19]` |
+| Phantom / Revolut | Polish as a trust signal in intimidating categories; price and perceived quality track together | `[26]` |
+| Intercom Fin / Dia | Outcome pricing (per resolved ticket); invisible UI and outcome-verb navigation | `[20]` |
+| Kraftful / Unbounce | One-CTA landing pages; proof placed where hesitation happens | `[27]` |
+| Discord / Stompers | Ambient social proof; Zeigarnik open loops as the whole screen | `[24]` |
+
+## Reference files
+
+- `references/behavioral-psychology.md` — 20 principles + 11 playbooks on the "why humans do this" layer: effort justification, dopamine anticipation, variable reward, identity, social comparison, loss aversion, peak–end, plus the ethical and regulatory limits.
+- `references/onboarding-activation.md` — first-run shapes (Granola vs Cal AI vs Noom), the two-justification test for length, permission-screen patterns, quiz templates, aha-moment design, and where the corpus contradicts itself on brevity.
+- `references/monetization-paywalls.md` — paywall audit order, trial-structure playbooks, weekly-vs-annual commitment data, plan-structure decoys, graduated gates for non-subscription products, and experimentation cadence.
+- `references/retention-gamification.md` — streaks, leaderboards, cohort sizing, competence feedback, reward ceremonies, done-state audits, community architecture, and the over-gamification overload zone.
+- `references/growth-marketing.md` — distribution-as-design, positioning against incumbents, the five moats, agent-era disruption audit, share/flex loops, and landing-page conversion rebuilds.
+- `references/design-craft.md` — the countable craft checklist (type, spacing, color, radii), the subtraction pass, motion and emotional feedback, microcopy repair, and the five-criterion screen audit.
+
+## Source index
+
+Every `[NN]` marker in this file and in `references/` points here. All credit to Tim Gabe.
+
+- `[01]` The Twisted Psychology Behind Top 1% Apps — https://www.youtube.com/watch?v=nQKWYmrixCU
+- `[02]` The Weird Design Playbook of 6 App Outliers — https://www.youtube.com/watch?v=HA4yB_sd62Q
+- `[03]` Why Leaderboards Kill App Retention (How To Fix It) — https://www.youtube.com/watch?v=BxhsCu9hNpY
+- `[04]` How Top 1% Indie Apps Beats Giants — https://www.youtube.com/watch?v=MAvKHToGiVY
+- `[05]` How To Solve The App Onboarding Paradox — https://www.youtube.com/watch?v=Aa89MC8jX2c
+- `[06]` I Studied 10,000 Paywall Screens (THIS Makes People Pay) — https://www.youtube.com/watch?v=sYRhXB_ZcLI
+- `[07]` I Studied 500+ Gamified Apps (Here's What Actually Works) — https://www.youtube.com/watch?v=LXX_qOA5D8E
+- `[08]` How a Chinese Unicorn App Out-Addicts Netflix — https://www.youtube.com/watch?v=7dCZrtH15zc
+- `[09]` How To Scientifically Design Addictive Apps — https://www.youtube.com/watch?v=yBpv5rZoBjA
+- `[10]` The 3-Stage Trick Behind Every Addictive App — https://www.youtube.com/watch?v=uoLpH_20qKw
+- `[11]` Why Most SaaS Companies Will Die in 2026 — https://www.youtube.com/watch?v=ZXWUg1e1PAs
+- `[12]` Our World Class App Design Formula — https://www.youtube.com/watch?v=wmTkiF23GRQ
+- `[13]` The New Way Apps Dominate in 2026 — https://www.youtube.com/watch?v=yYs7iv81Ppk
+- `[14]` How Addictive Apps Are Made — https://www.youtube.com/watch?v=AnL49w4yIOw
+- `[15]` Give Me 13 Minutes & I'll Grow Your App — https://www.youtube.com/watch?v=v1f9iYZ2GhQ
+- `[16]` How Netflix Made Us All Binge (Design Breakdown) — https://www.youtube.com/watch?v=hIm3d3JAsPw
+- `[17]` Viral Design Tricks from Spotify (Founder Playbook) — https://www.youtube.com/watch?v=Tpg0pxKHrCA
+- `[18]` What Founders Can Learn From Apple's Design Domination — https://www.youtube.com/watch?v=doiaMtD80p8
+- `[19]` The Tiny Design Rule Behind Top 1% Apps — https://www.youtube.com/watch?v=11h4H3TAGkM
+- `[20]` The Future of App Design is Invisible — https://www.youtube.com/watch?v=zRUoPIwCxfw
+- `[21]` How Tinder's Design Hacked Society — https://www.youtube.com/watch?v=4yKtlOWClhA
+- `[22]` The Hidden App Growth Killer (How To Avoid It) — https://www.youtube.com/watch?v=55hDj88zKa8
+- `[23]` Copy These SaaS Growth Tricks (It'll Blow Up Your Business) — https://www.youtube.com/watch?v=puldme__Ckk
+- `[24]` How Top 1% Apps Keep You Hooked — https://www.youtube.com/watch?v=D9SXaj6qQIQ
+- `[25]` Do Companies Really Need Designers Anymore? — https://www.youtube.com/watch?v=bOm9GDv96Tk
+- `[26]` The Secret Behind Weirdly Addictive Apps — https://www.youtube.com/watch?v=Du2lkZ_cux8
+- `[27]` Give Me 10 Minutes & I'll Boost Your Website Conversions — https://www.youtube.com/watch?v=TIfiy1fodDs
+- `[28]` How Raycast Reached a $100M+ Valuation (As a Small Startup) — https://www.youtube.com/watch?v=eWGNjTLK84c
+- `[29]` 5 Tools I Wish I Found Sooner (For Designers) — https://www.youtube.com/watch?v=qmJVN2158Mk
+- `[30]` 4 levels of UI/UX design (and BIG mistakes to avoid) — https://www.youtube.com/watch?v=86PGRyQjdzQ