---
name: "User onboarding"
repo: https://github.com/manojbajaj95/claude-gtm-plugin
source: https://github.com/manojbajaj95/claude-gtm-plugin/blob/HEAD/skills/user-onboarding/SKILL.md
license: "MIT"
install: "npx skills add manojbajaj95/claude-gtm-plugin --skill user-onboarding"
page: https://100xlab.com/resources/agent-skills/manojbajaj95-claude-gtm-plugin--user-onboarding--1qzyed1
---

# User Onboarding

## Workspace Context

Read bootstrap context before asking questions: `strategy/brand.md` for brand, audience, offer, channels, tools, constraints, and metrics; `about/me.md` for personal voice; `content/ideas.md` and `content/calendar.md` for content planning. Use legacy product-marketing context files only as fallback. Save generated drafts to `content/<platform>/drafts/YYYY-MM-DD_short-topic-slug.md`, and route durable learnings back to `strategy/brand.md`, `about/me.md`, or `content/ideas.md`.

## Operating Contract

This skill is self-contained for its frontmatter scope: use its local instructions, references, scripts, and assets as the playbook; ask only for missing task-specific inputs; hand off to adjacent skills instead of expanding scope; and return an actionable artifact, decision, plan, draft, or diagnostic.



## Scope

**Covers**
- Designing the first-time user experience (FTUE) from entry/signup → first value
- Defining activation / the “aha moment” and reducing time-to-value
- Creating a “first 30 seconds” experience and a “first mile” plan (milestones to activation)
- Onboarding mechanics: progressive disclosure, guided setup, empty states, templates, checklists, feedback loops
- Instrumentation + experiments to improve activation and early retention

**When to use**
- “Activation is low” / “users drop during signup/onboarding”
- “Time-to-value is too long”
- “The first session doesn’t feel magical”
- “We need an onboarding redesign / guided setup / empty state improvements”
- “Define our aha moment and design onboarding to get users there”
- “Create an onboarding experiment backlog + measurement plan”

**When NOT to use**
- You’re onboarding employees, customers to a service process, or running training (not product onboarding).
- You don’t have a stable value proposition / ICP (use `brand-messaging-and-positioning` or `product-market-fit-analysis` first).
- You need a full retention strategy beyond onboarding (use `customer-success-and-retention`).
- You need a conversion review of a marketing page or form (use `conversion-rate-optimization`).

## Inputs

**Minimum required**
- Product + ICP/segment(s) (1–2) and the primary job-to-be-done
- Platform + entry point (web/mobile; where FTUE starts)
- Best-available baseline metrics (even rough):
  - visit → signup → first key action → activation
  - time-to-value (time or sessions to first value)
  - D1 retention (if available)
- Current onboarding flow summary (steps/screens) and the biggest drop-off point(s)
- Constraints: timebox, eng/design capacity, allowed channels (in-app/email/push), privacy/legal/brand limits

**Missing-info strategy**
- Ask up to 5 questions from [references/INTAKE.md](references/INTAKE.md), then proceed.
- If metrics are missing, proceed with explicit assumptions and label confidence.
- Do not request secrets or PII; prefer aggregated funnels and redacted screenshots.

## Outputs (deliverables)

Produce an **Onboarding & Activation Pack** (Markdown in-chat; or as files if requested) containing:

1) Context snapshot (goal, segment, constraints, baseline)
2) Current FTUE map (step-by-step) + friction log
3) Activation / aha moment spec (behavioral definition + threshold + validation plan)
4) “First 30 seconds” experience spec (magic moment + success criteria)
5) “First mile” onboarding plan (milestones to activation; mechanics per milestone)
6) Experiment backlog (prioritized) + 3–5 experiment cards
7) Measurement + instrumentation plan (events, properties, dashboards, guardrails)
8) Rollout/rollback + risk plan
9) Risks / Open questions / Next steps (always included)

Templates and checklists:
- [references/TEMPLATES.md](references/TEMPLATES.md)
- [references/WORKFLOW.md](references/WORKFLOW.md)
- [references/CHECKLISTS.md](references/CHECKLISTS.md)
- [references/RUBRIC.md](references/RUBRIC.md)

## Workflow (7 steps)

### 1) Intake + goal framing (activation-first)
- **Inputs:** User prompt; [references/INTAKE.md](references/INTAKE.md).
- **Actions:** Define the primary segment and the activation outcome. Make the goal measurable (baseline → target, date). Capture constraints and guardrails (e.g., don’t increase drop-off, don’t add dark patterns).
- **Outputs:** Context snapshot + goal statement.
- **Checks:** Goal is one sentence with a metric, baseline, target, and date.

### 2) Map the current first-time journey (FTUE)
- **Inputs:** Current flow description/screens; funnel + drop-offs; support/sales notes if available.
- **Actions:** Create a step-by-step journey map from entry → first value. Log frictions (confusion, time, permissions, empty states, choice overload). Identify the single biggest leak.
- **Outputs:** FTUE map table + friction log + primary leak.
- **Checks:** Every step has a user goal, product action, and a measurable checkpoint (event or proxy).

### 3) Define the activation / “aha moment” (behavioral)
- **Inputs:** Candidate value behaviors; available events; retention definition (if any).
- **Actions:** Propose 3–5 candidate “aha” behaviors and pick one activation definition with a threshold (e.g., “creates X and shares Y within 7 days”). Specify how to validate (correlation with D7/D30; holdout if possible).
- **Outputs:** Activation/aha moment spec + validation plan + instrumentation needs.
- **Checks:** Activation is observable, repeatable, and measurable (not “understands value”).

### 4) Design the “first 30 seconds” (make it feel magical)
- **Inputs:** Primary leak + activation spec; constraints.
- **Actions:** Specify what the user should see/do/feel in the first 30 seconds:
  - Remove or defer non-essential setup (progressive disclosure).
  - Deliver a fast, native, interactive win (avoid passive carousel “tours”).
  - Provide immediate feedback and a clear next action.
- **Outputs:** First 30 seconds spec (screen/script + success criteria).
- **Checks:** A new user can reach a meaningful “win” within ~30 seconds (or you document why not and the best proxy).

### 5) Build the “first mile” plan (milestones → activation)
- **Inputs:** Activation spec; journey map; UX constraints.
- **Actions:** Break activation into 3–6 milestones (the “first mile”). For each milestone, define mechanics (guided setup, defaults, empty states, templates, checklists, feedback, progress). Ensure onboarding is “inside the product,” not detached from real actions.
- **Outputs:** First mile onboarding plan + updated journey map.
- **Checks:** Each milestone reduces time-to-value and has a leading-indicator metric.

### 6) Instrumentation + measurement plan
- **Inputs:** Current analytics/events; proposed milestones; guardrails.
- **Actions:** Define the minimum event schema and dashboards needed (funnel, time-to-value, activation rate, early retention). Add guardrails (support tickets, cancellations, performance).
- **Outputs:** Measurement plan + event list/properties + dashboard outline.
- **Checks:** Every experiment and milestone has a primary metric and at least one guardrail metric.

### 7) Prioritize experiments + quality gate
- **Inputs:** Candidate interventions; measurement plan; [references/CHECKLISTS.md](references/CHECKLISTS.md) and [references/RUBRIC.md](references/RUBRIC.md).
- **Actions:** Convert top opportunities into experiment cards; prioritize (Impact × Confidence ÷ Effort). Add rollout/rollback guidance. Run checklist + score rubric. Always include **Risks / Open questions / Next steps**.
- **Outputs:** Final Onboarding & Activation Pack.
- **Checks:** Top 3 experiments are runnable within constraints and have “win/lose/learn” criteria.

## Quality gate (required)
- Use [references/CHECKLISTS.md](references/CHECKLISTS.md) and [references/RUBRIC.md](references/RUBRIC.md).
- Always include: **Risks**, **Open questions**, **Next steps**.

## Examples

**Example 1 (B2B SaaS, guided setup):**  
“Use `user-onboarding`. Product: workflow automation tool for SMB ops. Segment: new self-serve admins. Baseline: 42% signup completion, 9% activation within 7 days. Problem: users stall at connecting integrations. Constraint: 3-week sprint, 1 engineer, 1 designer. Output: an Onboarding & Activation Pack with an activation spec, a first-30-seconds + first-mile plan, and a prioritized experiment backlog.”

**Example 2 (B2C app, time-to-value):**  
“Our first session feels flat. Redesign onboarding so users experience value within 30 seconds, define the activation event, and propose 5 experiments with metrics + guardrails.”

**Boundary example (not product onboarding):**  
“Create an employee onboarding program for new hires.”  
Response: this skill is for product onboarding; use an HR onboarding/training process instead.

---

## Supporting file: references/CHECKLISTS.md

# CHECKLISTS (User Onboarding)

Use these checklists before finalizing the Onboarding & Activation Pack.

## A) Scope + boundary checklist
- [ ] This is **product onboarding/FTUE**, not HR/service onboarding.
- [ ] Primary segment(s) are defined (1–2) and used throughout the plan.
- [ ] Goal includes baseline → target + date; guardrails are explicit.
- [ ] Assumptions are clearly labeled (especially if metrics are missing).

## B) Activation (“aha moment”) checklist
- [ ] Activation is **behavioral** and measurable (event + threshold + time window).
- [ ] There is a plan to validate (correlation with retention; experiment if possible).
- [ ] Activation ties to user value (not just product usage).

## C) First 30 seconds checklist (make it feel magical)
- [ ] The first 30 seconds has a clear “win” (or best proxy is stated).
- [ ] Non-essential setup is deferred (progressive disclosure).
- [ ] Onboarding is interactive; no reliance on passive carousel tours.
- [ ] The product provides immediate feedback and a clear next action.

## D) First mile checklist (milestones → activation)
- [ ] Milestones are 3–6 steps that map to real product actions.
- [ ] Each milestone includes mechanics (templates/defaults/empty states/checklists).
- [ ] Each milestone has a leading-indicator metric and reduces time-to-value.

## E) Measurement + experiment readiness checklist
- [ ] Every proposed experiment has a primary metric + at least one guardrail.
- [ ] Instrumentation needs are listed (events + properties).
- [ ] Rollout/rollback is specified with triggers and monitoring.
- [ ] Risks, open questions, and next steps are included.

---

## Supporting file: references/EXAMPLES.md

# EXAMPLES (User Onboarding)

Use these as reference patterns for what “good” looks like.

## Example 1 — B2B SaaS (integration-heavy setup)

**Context:** Team analytics tool. New admins must connect 1+ integrations before value appears.  
**Goal:** Increase 7-day activation from 12% → 18% by end of quarter; don’t reduce signup completion.  
**Good solution characteristics:**
- First 30 seconds uses **demo data** + a “preview dashboard” so value is immediate.
- First mile milestones: (1) see demo insights, (2) connect first integration, (3) invite teammate, (4) run first report.
- Experiment backlog includes: permission-copy changes, integration defaults, “connect later” deferral, and a guided checklist with progress.

## Example 2 — B2C app (blank-state + choice overload)

**Context:** Fitness app with many programs; new users get overwhelmed.  
**Goal:** Reduce time-to-first-workout from 10 minutes → 3 minutes; increase first-win rate.  
**Good solution characteristics:**
- First 30 seconds: default a “starter workout” with one tap; minimal questions up front.
- First mile plan: progressively collect preferences after first win, not before.
- Guardrails include refunds/cancellations and support tickets.

## Boundary example — Not a product onboarding problem

**Prompt:** “Write a training program for new customer success hires.”  
**Response:** Not in scope; use an HR onboarding/training process. This skill targets in-product onboarding and activation.

---

## Supporting file: references/INTAKE.md

# INTAKE (User Onboarding)

Ask up to **5 questions at a time**. If answers aren’t available, proceed with explicit assumptions (and label confidence).

## 1) Context
- What is the product, and what is the primary job-to-be-done?
- Who is the target user/ICP? Define 1–2 onboarding segments (e.g., “new self-serve admins”, “mobile creators”, “teams with 3–10 seats”).
- Stage: pre-PMF / early PMF / growth / mature?

## 2) Goal (make it measurable)
- What metric should improve (activation rate, signup completion, time-to-value, D1 retention)?
- What’s the baseline and target? By what date?
- Guardrails / non-goals (don’t increase drop-off, don’t increase support tickets, don’t add spammy nags, don’t degrade performance).

## 3) Current onboarding flow + biggest leak
- Where does first-time onboarding start (landing page, invite link, app store, deep link)?
- Describe the current steps/screens from entry → first value. Where do users drop the most?
- What are the top 3 user confusions/frictions you already suspect?

## 4) “Aha moment” (activation) hypotheses
- What does “success” look like for a new user in the first session/day/week?
- What behavior(s) do retained users do early (if known)?
- Any hard constraints (permissions required, data imports, integrations, teammate invites)?

## 5) Platform + UX constraints
- Web / iOS / Android / desktop? Any policy constraints (e.g., iOS permissions prompts)?
- What onboarding mechanics are allowed (guided setup, templates, checklists, demo data, progressive disclosure, lifecycle emails/push)?
- Anything you must avoid (non-native frameworks, heavy tours/carousels, incentives)?

## 6) Data & instrumentation (no secrets needed)
- What analytics stack do you use (Amplitude/Mixpanel/GA/warehouse)?
- Do you have stable user IDs across sessions/devices?
- Which events are already tracked for signup, key actions, activation, and early retention?

## 7) Capacity + timeline
- Timebox (days/weeks) and team capacity (design/eng/data)?
- Release cadence and rollout constraints (feature flags, A/B testing capability, localization)?

---

## Supporting file: references/RUBRIC.md

# RUBRIC (User Onboarding Skill Output)

Score each item 0/1/2:
- 0 = missing / unusable
- 1 = present but incomplete
- 2 = clear, executable, reusable

Suggested passing bar: **>= 16/20**.

## 1) Goal clarity (0–2)
- The goal includes baseline → target and a date.
- Guardrails are explicit.

## 2) Segmentation (0–2)
- 1–2 segments are defined and the plan is tailored to them.

## 3) Journey map + friction log (0–2)
- FTUE steps are mapped end-to-end with measurable checkpoints.
- Top frictions are ranked and tied to fixes.

## 4) Activation definition (0–2)
- Activation/aha moment is behavioral, measurable, and tied to user value.

## 5) First 30 seconds quality (0–2)
- The “first win” is concrete and achievable quickly (or proxy is justified).
- Design avoids passive tours and focuses on interactive value.

## 6) First mile plan quality (0–2)
- Milestones are specific, realistic, and reduce time-to-value.
- Each milestone includes mechanics + metrics.

## 7) Measurement plan (0–2)
- Minimum viable event schema is defined.
- Dashboards and owners (if known) are specified.

## 8) Experiments (0–2)
- Backlog is prioritized with a clear scoring model.
- Top experiments have “win/lose/learn” criteria and rollout/rollback plans.

## 9) Safety + ethics (0–2)
- Avoids dark patterns; respects privacy; no secrets/PII requested.

## 10) Finalization (0–2)
- Includes **Risks**, **Open questions**, and **Next steps**.
- Output is structured, copy/paste-ready, and high signal.

---

## Supporting file: references/SOURCE_SUMMARY.md

# SOURCE SUMMARY (Refound/Lenny → User Onboarding)

Source: `sources/refound/raw/user-onboarding/SKILL.md`

## Original insights (preserved)

- **Onboarding is a major unlock** even when product features exist: onboarding can be “the thing holding people back.” (Cam Adams)
- The biggest retention wins often come from **inflecting the early user experience**. (Dan Hockenmaier)
- Optimize the **first 30 seconds** to feel “magical,” and treat onboarding like the “first mile” that drives word-of-mouth. (Grant Lee)
- Apply **game design principles**: onboarding should be part of the product experience; avoid common traps like passive carousels and non-native experiences. (Merci Grace)

## How the skill pack transforms insights into execution

Each insight becomes a rule + check + artifact:

1) **Rule:** Treat onboarding as a core product surface, not an afterthought.  
   **Check:** Biggest onboarding leak is identified and tied to a concrete fix plan.  
   **Artifact:** FTUE Journey Map + Friction Log (`references/TEMPLATES.md`).

2) **Rule:** Optimize for early experience → activation → early retention.  
   **Check:** Activation (“aha moment”) is defined behaviorally and has a validation plan.  
   **Artifact:** Activation / Aha Moment Spec (`references/TEMPLATES.md`).

3) **Rule:** Make the first 30 seconds deliver a fast, interactive win.  
   **Check:** First-win event is measurable and realistic; non-essential setup is deferred.  
   **Artifact:** First 30 Seconds Spec (`references/TEMPLATES.md`).

4) **Rule:** Design the “first mile” as milestones to activation with feedback and progress.  
   **Check:** 3–6 milestones; each has mechanics + leading metrics; no “tour-only” steps.  
   **Artifact:** First Mile Plan (`references/TEMPLATES.md`).

5) **Rule:** Make onboarding improvements testable and measurable.  
   **Check:** Every experiment has a primary metric + guardrail + rollout/rollback.  
   **Artifact:** Experiment Card + Measurement Plan (`references/TEMPLATES.md`).

## Notes on boundaries
- This skill is strictly **product user onboarding** (FTUE), not HR onboarding.
- If ICP/value prop is unclear, route to `brand-messaging-and-positioning` or `product-market-fit-analysis`.
- If broad retention beyond onboarding is the goal, route to `customer-success-and-retention`.

---

## Supporting file: references/TEMPLATES.md

# TEMPLATES (User Onboarding)

Copy/paste the templates below. Keep everything in plain language; avoid jargon in user-facing copy.

## 1) Onboarding Brief (context + goal)

**Product:**  
**Segment(s):**  
**Stage:** pre-PMF / early PMF / growth / mature  
**Platform(s):** web / iOS / Android / desktop  
**FTUE entry point:** (e.g., invite link, app store, marketing site → signup)  

**Goal (baseline → target by date):**  
**Primary metric:**  
**Guardrails:** (support tickets, drop-off, revenue, performance, unsubscribes)  

**Constraints:** (timebox, capacity, policies, privacy/legal/brand)  
**Non-goals / “do not do” list:**  

## 2) FTUE Journey Map (step-by-step)

| Step # | User goal | What the product asks | Value delivered (if any) | Friction / confusion | Current metric (event/proxy) |
|---:|---|---|---|---|---|
| 1 |  |  |  |  |  |

### Friction Log

| Friction | Where it happens | Likely cause | Severity (H/M/L) | Fix idea (short) |
|---|---|---|---|---|
|  |  |  |  |  |

## 3) Activation / “Aha Moment” Spec

**Candidate aha behaviors (3–5):**
- 1)
- 2)
- 3)

**Chosen activation definition (behavioral):**  
**Threshold / time window:** (e.g., “does X twice within 7 days”)  
**Why this is value (user POV):**  
**Why this predicts retention (business POV):**  

**Validation plan:**
- Correlate activation with D7/D30 retention (by segment)
- If possible: experiment/holdout to test causality

**Instrumentation requirements:** (events + properties you must track)

## 4) First 30 Seconds Spec (“make it feel magical”)

**Entry context:** (new user path, permissions, default state)  
**One-sentence promise:** (what the user will get right away)  
**The “win” in 30 seconds:** (what the user accomplishes)  

**Script (what happens):**
1) User sees…
2) User does…
3) Product responds with…
4) Next step CTA is…

**Design principles:**
- Defer non-essential questions (progressive disclosure)
- Prefer interactive doing over passive reading
- Provide instant feedback + visible progress

**Success criteria (measurable):**
- Time-to-first-win: ___ seconds
- % users reaching first-win event: ___
- Guardrail(s): ___

## 5) First Mile Plan (milestones → activation)

**Milestones (3–6):**

| Milestone # | User intent | Product mechanic(s) | What “done” looks like | Leading indicator metric |
|---:|---|---|---|---|
| 1 |  |  |  |  |

**Notes:**
- Each milestone should use real product actions (avoid “tour-only” steps).
- Use defaults/templates/demo data to reduce blank-state pain.

## 6) Experiment Backlog (prioritized)

Scoring: **Impact × Confidence ÷ Effort** (1–5 each).

| Rank | Experiment | Hypothesis | Primary metric | Guardrail | ICE score | Effort notes |
|---:|---|---|---|---|---:|---|
| 1 |  |  |  |  |  |  |

### Experiment Card

**Name:**  
**Problem / insight:**  
**Hypothesis:** If we ___ then ___ because ___.  
**Change:** (what exactly changes in product)  
**Audience:** (segment, new vs returning, platform)  
**Primary metric:**  
**Guardrails:**  
**Instrumentation:** (events/properties needed)  
**Duration / sample:**  
**Rollout:** (feature flag, % ramp, holdout)  
**Rollback plan:**  
**Risks / edge cases:**  

## 7) Measurement + Instrumentation Plan

**Key definitions:**
- Signup completion = …
- First key action = …
- First-win event = …
- Activation event = …

**Event schema (minimum viable):**

| Event | When fired | Key properties | Used in |
|---|---|---|---|
| signup_started |  |  | funnel |
| signup_completed |  |  | funnel |
| first_win_completed |  |  | time-to-value |
| activated |  |  | activation rate |

**Dashboards to create:**
- FTUE funnel (by segment/platform)
- Time-to-first-win distribution (median/p75)
- Activation rate + early retention (D1/D7) by segment
- Guardrails (support tickets, performance, unsubscribes)

## 8) Rollout / Rollback Plan

**Release mechanism:** feature flag / staged rollout / A/B test  
**Ramp plan:** 0% → 10% → 50% → 100% with checkpoints  
**Monitor:** primary metric + guardrails + errors/perf  
**Rollback trigger:** (what number or signal forces rollback)  
**Comms:** (internal + external if needed)

---

## Supporting file: references/WORKFLOW.md

# WORKFLOW (User Onboarding → Activation)

Use this workflow to produce an **Onboarding & Activation Pack**. Copy/paste templates from `references/TEMPLATES.md`.

## Step 1 — Intake + goal framing
- Fill: **Onboarding Brief** template.
- Output: a measurable goal + guardrails + constraints.
- Gate: goal includes baseline → target + date.

## Step 2 — Map the current FTUE (first-time user experience)
- Fill: **FTUE Journey Map** + **Friction Log** templates.
- Output: the biggest leak + the top 5 frictions ranked by impact.
- Gate: each step has an event/proxy metric.

## Step 3 — Define activation (“aha moment”) and validate
- Fill: **Activation / Aha Moment Spec** template.
- Output: a single activation definition + threshold + validation plan.
- Gate: activation is behavioral + measurable.

## Step 4 — Design the first 30 seconds (fast, interactive win)
- Fill: **First 30 Seconds Spec** template.
- Output: the exact first-run script (what the user sees/does) + success criteria.
- Gate: “meaningful win” in ~30 seconds (or best proxy clearly stated).

## Step 5 — Build the first mile plan (milestones → activation)
- Fill: **First Mile Plan** template.
- Output: 3–6 milestones, each with mechanics + leading-indicator metrics.
- Gate: milestones reduce time-to-value; no “tour-only” steps.

## Step 6 — Instrumentation + measurement
- Fill: **Measurement Plan** template.
- Output: event schema + funnel + dashboard outline + guardrails.
- Gate: every milestone and experiment has primary + guardrail metrics.

## Step 7 — Experiment backlog + rollout plan + quality gate
- Fill: **Experiment Backlog** + **Experiment Card** + **Rollout/Rollback Plan** templates.
- Output: prioritized experiments and a release plan.
- Gate: run `references/CHECKLISTS.md`, score `references/RUBRIC.md`, and include **Risks / Open questions / Next steps**.

---

## Supporting file: skillpack.json

```json
{
  "authors": [
    "liqiongyu"
  ],
  "category": "Growth",
  "contributors": [],
  "origin": "refound",
  "schema_version": 1,
  "skill_slug": "user-onboarding",
  "upstream": {
    "page_url": "https://refoundai.com/lenny-skills/s/user-onboarding",
    "skill_md_url": "https://refoundai.com/skills/user-onboarding/SKILL.md"
  },
  "version": "0.1.0"
}
```