home / skills / phrazzld / claude-config / log-onboarding-issues

log-onboarding-issues skill

/skills/log-onboarding-issues

This skill audits onboarding, lists findings by priority, checks for duplicates, and creates GitHub issues with structured templates.

npx playbooks add skill phrazzld/claude-config --skill log-onboarding-issues

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.9 KB
---
name: log-onboarding-issues
description: |
  Run /check-onboarding, then create GitHub issues for all findings.
  Issues are created with priority labels and structured format.
  Use /fix-onboarding instead if you want to fix issues immediately.
effort: medium
---

# /log-onboarding-issues

Run onboarding audit and create GitHub issues for all findings.

## What This Does

1. Invoke `/check-onboarding` to audit new user experience
2. Parse findings by priority (P0-P3)
3. Check existing issues to avoid duplicates
4. Create GitHub issues for each finding

**This is an issue-creator.** It creates work items, not fixes. Use `/fix-onboarding` to fix issues.

## Process

### 1. Run Primitive

Invoke `/check-onboarding` skill to get structured findings.

### 2. Check Existing Issues

```bash
gh issue list --state open --label "domain/onboarding" --limit 50
```

### 3. Create Issues

For each finding:

```bash
gh issue create \
  --title "[P0] No onboarding flow - users dropped into empty app" \
  --body "$(cat <<'EOF'
## Problem
After signup, users land on an empty dashboard with no guidance. They don't know what to do first.

## Impact
- High drop-off after signup
- Users never experience core value
- Support tickets asking "how do I start?"
- Lost users who never return

## Suggested Fix
Run `/fix-onboarding` or implement:

1. **First-run detection:**
```typescript
const isNewUser = !user.hasCompletedOnboarding;
if (isNewUser) redirect('/onboarding');
```

2. **Onboarding wizard:**
- Welcome screen
- First action prompt
- Success celebration

3. **Empty state with CTA:**
"Create your first X to get started"

---
Created by `/log-onboarding-issues`
EOF
)" \
  --label "priority/p0,domain/onboarding,type/enhancement"
```

### 4. Issue Format

**Title:** `[P{0-3}] Onboarding issue`

**Labels:**
- `priority/p0` | `priority/p1` | `priority/p2` | `priority/p3`
- `domain/onboarding`
- `type/enhancement` | `type/bug`

**Body:**
```markdown
## Problem
What's broken in new user experience

## Impact
Effect on activation and retention

## Suggested Fix
Code snippet, pattern, or skill to run

---
Created by `/log-onboarding-issues`
```

## Priority Mapping

| Gap | Priority |
|-----|----------|
| No onboarding flow | P0 |
| Broken auth callback | P0 |
| Paywall before value | P0 |
| No empty states | P1 |
| No first-action guidance | P1 |
| Complex initial forms | P1 |
| No loading states | P1 |
| No progressive disclosure | P2 |
| No tooltips/hints | P2 |
| No tour option | P2 |
| Retention hooks missing | P3 |

## Output

After running:
```
Onboarding Issues Created:
- P0: 1 (no onboarding flow)
- P1: 4 (empty states, guidance, forms)
- P2: 3 (progressive disclosure, hints)
- P3: 2 (notifications, email capture)

Total: 10 issues created
View: gh issue list --label domain/onboarding
```

## Related

- `/check-onboarding` - The primitive (audit only)
- `/fix-onboarding` - Fix onboarding issues
- `/cro` - Conversion optimization
- `/groom` - Full backlog grooming

Overview

This skill runs an onboarding audit and creates GitHub issues for every finding so teams can prioritize and track fixes. It classifies gaps by priority (P0–P3), avoids duplicates by checking existing issues, and posts structured issues with labels and suggested fixes. Use this to convert audit results into actionable work items rather than performing automatic repairs.

How this skill works

The skill invokes the /check-onboarding audit to collect structured findings. It maps each finding to a priority level, queries open GitHub issues with the onboarding domain label to prevent duplicates, and then creates new issues using a consistent title, labels, and a three-part body (Problem, Impact, Suggested Fix). Each created issue includes a reference to the skill that generated it.

When to use it

  • After running or scheduling an onboarding audit (/check-onboarding).
  • When you need a prioritized backlog of user-experience problems for new users.
  • Before sprint planning to seed work items for UX, product, and engineering.
  • When you want traceable recommendations rather than automated changes.
  • When you need consistent issue formatting for reporting and handoff.

Best practices

  • Run /check-onboarding regularly or after major onboarding changes to capture regressions.
  • Review the suggested fixes in issues before assigning to engineers; they are starting points, not final implementations.
  • Use the priority labels (priority/p0–priority/p3) to triage work quickly in planning sessions.
  • Keep the domain/onboarding label on related issues to enable scoped searches and reports.
  • Combine with /fix-onboarding for high-priority findings you want to remediate immediately.

Example use cases

  • Post-launch smoke check: run audit and create issues for any onboarding regressions after a release.
  • Backlog generation: populate a sprint-ready queue of UX tasks for product and design to estimate.
  • Audit-driven QA: convert discovery findings into tracked issues for engineering to pick up.
  • Stakeholder reporting: produce a prioritized list of onboarding gaps to present at planning or review meetings.
  • Continuous improvement: schedule weekly audits and issue creation to incrementally reduce activation friction.

FAQ

Will this skill automatically fix problems it finds?

No. This skill only creates GitHub issues documenting problems and suggested fixes. Use /fix-onboarding to attempt automated fixes.

How does it avoid creating duplicate issues?

It lists open issues with the domain/onboarding label and checks titles or similar findings before creating new issues to reduce duplicates.

How are priorities determined?

Findings from /check-onboarding are mapped to priority levels (P0–P3) based on impact categories like missing flow, broken auth, or minor hints.