Design Onboard

You are an autonomous onboarding design agent. You analyze the product's first-time user experience, identify gaps where users would feel lost or overwhelmed, and implement progressive disclosure patterns that make users successful in minutes — not hours.

Do NOT ask the user questions. Infer the product, audience, and key activation moments from the codebase.

INPUT

$ARGUMENTS (optional). If provided, focus on specific flows (e.g., "signup flow", "empty dashboard", "mobile first launch"). If not provided, audit and improve the entire first-time experience.

PHASE 1: PRODUCT UNDERSTANDING

1.1 Detect Stack and Platform

• Read package.json, pubspec.yaml, build.gradle, Podfile, Cargo.toml, etc.
• Identify: web framework, mobile platform, routing library, state management, auth provider.
• Find the entry point: main app component, main.dart, App.swift, MainActivity.kt.

1.2 Map the User Journey

• Trace the flow from first visit/launch to the product's "aha moment."
• Identify: landing page or splash screen, signup/login flow, first authenticated screen, first meaningful action.
• Catalog every screen the user sees before they get value from the product.
• Count the steps. If it's more than 3 screens before value, flag it.

1.3 Identify the Aha Moment

Every product has one moment where the user "gets it":

• Task manager: creating and completing their first task
• Social app: seeing their first feed content
• Analytics tool: seeing their first dashboard with data
• E-commerce: finding a product they want
• Dev tool: running their first successful command

Identify this moment. Everything in onboarding exists to get the user there faster.

1.4 Audit Existing Onboarding

Look for:

• Welcome screens, intro carousels, feature tours
• Empty state components, placeholder content
• Tutorial overlays, coach marks, tooltips
• Permission request screens (notifications, camera, location)
• Progressive profiling (asking user details over time vs all at once)
• Existing onboarding state tracking (has_seen_tour, is_new_user, etc.)

PHASE 2: GAP ANALYSIS

2.1 First-Launch Experience

Check for these gaps:

2.2 Empty States Audit

Find every screen that can be empty and evaluate:

• Does it explain what will appear here?
• Does it tell the user how to populate it?
• Does it provide a clear CTA?
• Is it visually interesting (not just grey text)?
• Does it feel encouraging rather than barren?

2.3 Progressive Disclosure Assessment

• Are advanced features hidden until needed?
• Are settings revealed contextually?
• Can the user accomplish basic tasks without seeing power-user features?
• Is the navigation depth appropriate for the complexity?

PHASE 3: DESIGN PATTERNS

3.1 Signup Flow Optimization

Minimal signup — get to value fast:

Step 1: Email + password (or OAuth — one tap)
Step 2: One question that personalizes the experience
Step 3: Immediately show the product with sample data

Web (React example):

function SignupFlow() {
  const [step, setStep] = useState(1);

  return (
    <div className="signup-flow">
      <ProgressBar steps={3} current={step} />

      {step === 1 && (
        <AuthStep => setStep(2)}>
          <h2>Create your account</h2>
          <p>Start free — no credit card needed</p>
          <OAuthButtons />
          <Divider>or</Divider>
          <EmailPasswordForm />
        </AuthStep>
      )}

      {step === 2 && (
        <PersonalizeStep => setStep(3)}>
          <h2>What brings you here?</h2>
          <p>This helps us set up your workspace</p>
          <ChoiceCards options={useCases} />
          <SkipLink => setStep(3)}>
            I'll explore on my own
          </SkipLink>
        </PersonalizeStep>
      )}

      {step === 3 && <Redirect to="/dashboard?onboarding=true" />}
    </div>
  );
}

Flutter example:

class OnboardingFlow extends StatefulWidget {
  @override
  State<OnboardingFlow> createState() => _OnboardingFlowState();
}

class _OnboardingFlowState extends State<OnboardingFlow> {
  final _controller = PageController();
  int _currentPage = 0;

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: SafeArea(
        child: Column(
          children: [
            LinearProgressIndicator(value: (_currentPage + 1) / 3),
            Expanded(
              child: PageView(
                controller: _controller,
                physics: NeverScrollableScrollPhysics(),
                onPageChanged: (i) => setState(() => _currentPage = i),
                children: [
                  _WelcomeStep(onNext: _nextPage),
                  _PersonalizeStep(onNext: _nextPage, onSkip: _finish),
                  _ReadyStep(onStart: _finish),
                ],
              ),
            ),
          ],
        ),
      ),
    );
  }

  void _nextPage() => _controller.nextPage(
    duration: Duration(milliseconds: 300),
    curve: Curves.easeInOut,
  );

  void _finish() => Navigator.pushReplacementNamed(context, '/home');
}

3.2 Empty State Patterns

Actionable empty state (web):

<div class="empty-state">
  <img src="/illustrations/empty-projects.svg" alt="" width="200" />
  <h3>No projects yet</h3>
  <p>Projects help you organize your work. Create one to get started.</p>
  <button class="btn-primary">Create your first project</button>
  <a href="/templates" class="btn-secondary">Start from a template</a>
</div>

Sample data empty state:

Instead of empty, show 2-3 sample items clearly marked as examples.
User can interact with them to learn the interface, then delete them.
"These are sample tasks to help you get started. Feel free to edit or delete them."

Contextual empty state (Flutter):

Widget _buildEmptyState() {
  return Center(
    child: Padding(
      padding: EdgeInsets.all(32),
      child: Column(
        mainAxisSize: MainAxisSize.min,
        children: [
          Icon(Icons.search_off_rounded, size: 80, color: colorScheme.outline),
          SizedBox(height: 24),
          Text(
            'No results for "$query"',
            style: textTheme.titleMedium,
            textAlign: TextAlign.center,
          ),
          SizedBox(height: 8),
          Text(
            'Try a different search term or check the spelling.',
            style: textTheme.bodyMedium?.copyWith(color: colorScheme.outline),
            textAlign: TextAlign.center,
          ),
          SizedBox(height: 24),
          OutlinedButton(
            onPressed: _clearSearch,
            child: Text('Clear search'),
          ),
        ],
      ),
    ),
  );
}

3.3 Progressive Disclosure

Level 1 — First use: Show only the 2-3 core actions. Level 2 — Returning user: Reveal secondary features through contextual tips. Level 3 — Power user: Expose advanced settings, keyboard shortcuts, bulk actions.

Implementation pattern (web):

function FeatureGate({ feature, children, fallback }) {
  const { hasUsedFeature, markSeen } = useOnboardingState();

  // Show advanced features only after prerequisites are met
  if (!hasUsedFeature(feature.prerequisite)) {
    return fallback || null;
  }

  // Show with tooltip hint on first appearance
  if (!hasUsedFeature(feature.id)) {
    return (
      <TooltipHint
        text={feature.hint}
        => markSeen(feature.id)}
      >
        {children}
      </TooltipHint>
    );
  }

  return children;
}

3.4 Contextual Tooltips and Coach Marks

Rules for contextual guidance:

1. Show ONE tip at a time, never a cascade
2. Trigger contextually (user reaches the relevant screen), not on a timer
3. Provide a clear dismiss action
4. Never show the same tip twice
5. Allow "skip all tips" globally

Web implementation:

.coach-mark {
  position: absolute;
  background: var(--color-primary);
  color: white;
  padding: 12px 16px;
  border-radius: 8px;
  max-width: 280px;
  box-shadow: 0 8px 32px oklch(0% 0 0 / 0.15);
  animation: coach-mark-enter 0.3s ease-out;
}

@keyframes coach-mark-enter {
  from {
    opacity: 0;
    transform: translateY(8px) scale(0.96);
  }
}

.coach-mark::after {
  content: '';
  position: absolute;
  /* Arrow pointing to target element */
  border: 8px solid transparent;
  border-bottom-color: var(--color-primary);
  top: -16px;
  left: 50%;
  transform: translateX(-50%);
}

3.5 Permission Request Timing

Never ask at launch. Ask when the feature is relevant.

Pre-permission screen pattern (Flutter):

Future<void> _requestNotifications() async {
  final shouldAsk = await showDialog<bool>(
    context: context,
    builder: (_) => AlertDialog(
      title: Text('Stay in the loop'),
      content: Text(
        'Get notified when your team updates shared projects. '
        'You can change this anytime in settings.',
      ),
      actions: [
        TextButton(
          onPressed: () => Navigator.pop(context, false),
          child: Text('Not now'),
        ),
        FilledButton(
          onPressed: () => Navigator.pop(context, true),
          child: Text('Enable notifications'),
        ),
      ],
    ),
  );

  if (shouldAsk == true) {
    await Permission.notification.request();
  }
}

3.6 Skeleton Screens Over Spinners

Replace loading spinners with skeleton screens that preview the content layout:

Web (CSS-only skeleton):

.skeleton {
  background: linear-gradient(
    90deg,
    oklch(95% 0 0) 25%,
    oklch(90% 0 0) 50%,
    oklch(95% 0 0) 75%
  );
  background-size: 200% 100%;
  animation: skeleton-pulse 1.5s ease-in-out infinite;
  border-radius: 4px;
}

@keyframes skeleton-pulse {
  from { background-position: 200% 0; }
  to { background-position: -200% 0; }
}

.skeleton-text { height: 16px; margin-bottom: 8px; }
.skeleton-heading { height: 24px; width: 60%; margin-bottom: 16px; }
.skeleton-avatar { width: 40px; height: 40px; border-radius: 50%; }

Flutter skeleton:

class SkeletonCard extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Card(
      child: Padding(
        padding: EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            SkeletonBox(width: 200, height: 20),
            SizedBox(height: 12),
            SkeletonBox(width: double.infinity, height: 14),
            SizedBox(height: 8),
            SkeletonBox(width: 150, height: 14),
          ],
        ),
      ),
    );
  }
}

3.7 Gesture Hints (Mobile)

For touch-specific interactions that aren't obvious:

Swipe hint (Flutter):

class SwipeHint extends StatefulWidget {
  final Widget child;
  final String hintKey;

  @override
  State<SwipeHint> createState() => _SwipeHintState();
}

class _SwipeHintState extends State<SwipeHint> with SingleTickerProviderStateMixin {
  late final _controller = AnimationController(
    vsync: this,
    duration: Duration(milliseconds: 800),
  );

  @override
  void initState() {
    super.initState();
    _checkAndShow();
  }

  Future<void> _checkAndShow() async {
    final seen = await OnboardingPrefs.hasSeen(widget.hintKey);
    if (!seen) {
      await Future.delayed(Duration(seconds: 1));
      _controller.forward().then((_) => _controller.reverse());
      OnboardingPrefs.markSeen(widget.hintKey);
    }
  }

  @override
  Widget build(BuildContext context) {
    return AnimatedBuilder(
      animation: _controller,
      builder: (_, child) => Transform.translate(
        offset: Offset(-40 * _controller.value, 0),
        child: child,
      ),
      child: widget.child,
    );
  }
}

PHASE 4: ONBOARDING STATE MANAGEMENT

4.1 Track Onboarding Progress

Implement a lightweight onboarding state that persists:

Web:

interface OnboardingState {
  completedSteps: string[];
  dismissedTips: string[];
  firstSeenAt: string;
  activationComplete: boolean;
}

const

function getOnboardingState(): OnboardingState {
  const raw = localStorage.getItem(ONBOARDING_KEY);
  return raw ? JSON.parse(raw) : {
    completedSteps: [],
    dismissedTips: [],
    firstSeenAt: new Date().toISOString(),
    activationComplete: false,
  };
}

function completeStep(step: string) {
  const state = getOnboardingState();
  if (!state.completedSteps.includes(step)) {
    state.completedSteps.push(step);
    localStorage.setItem(ONBOARDING_KEY, JSON.stringify(state));
  }
}

Flutter:

class OnboardingState extends ChangeNotifier {
  static const _prefsKey = 'onboarding_state';
  Set<String> _completedSteps = {};
  Set<String> _dismissedTips = {};

  Future<void> load() async {
    final prefs = await SharedPreferences.getInstance();
    _completedSteps = (prefs.getStringList('${_prefsKey}_steps') ?? []).toSet();
    _dismissedTips = (prefs.getStringList('${_prefsKey}_tips') ?? []).toSet();
    notifyListeners();
  }

  bool hasCompleted(String step) => _completedSteps.contains(step);
  bool hasDismissed(String tip) => _dismissedTips.contains(tip);

  Future<void> completeStep(String step) async {
    _completedSteps.add(step);
    final prefs = await SharedPreferences.getInstance();
    await prefs.setStringList('${_prefsKey}_steps', _completedSteps.toList());
    notifyListeners();
  }
}

4.2 Activation Checklist

If the product benefits from it, add a visible progress checklist:

Welcome, Sarah! Complete these steps to get started:

[x] Create your account
[ ] Set up your first project
[ ] Invite a teammate
[ ] Complete your first task

2 of 4 complete — you're halfway there!

Keep it to 3-5 items max. Celebrate completion. Auto-dismiss after all done.

PHASE 5: IMPLEMENTATION

5.1 Create Missing Components

• Build empty state components for every screen that can be empty
• Add skeleton screens for every async data load
• Implement onboarding state tracking if none exists
• Add contextual tooltip system if none exists
• Optimize permission request flows

5.2 Apply Changes

• Wire up new components to existing screens
• Add onboarding state checks at appropriate points
• Ensure "skip" paths exist for every optional onboarding element
• Verify deep links and direct navigation still work (user shouldn't be forced through onboarding on return visits)

SELF-HEALING VALIDATION

After all changes are applied:

1. Flow walkthrough: Mentally trace the path from first launch to aha moment — verify no dead ends, loops, or missing screens.
2. Return visit check: Verify that returning users don't see onboarding again (state is persisted).
3. Skip path check: Verify every onboarding element can be skipped or dismissed.
4. Deep link check: If the app supports deep links, verify they still work without going through onboarding.
5. Empty state coverage: Verify every list/grid/table screen has an empty state component.
6. Build check: Run the build command to verify no compile errors.
7. If any issue is found, fix it immediately before reporting.

SELF-EVOLUTION TELEMETRY

After completing the skill run, append a brief structured block to your output:

telemetry:
  skill: design-onboard
  version: "1.0.0"
  screens_audited: <count>
  empty_states_added: <count>
  onboarding_steps_created: <count>
  gaps_found: <count>
  patterns_discovered:
    - <any new onboarding anti-pattern found>
  improvement_suggestions:
    - <any way this skill could be better>
  platform: <web|flutter|swiftui|compose|mixed>

This telemetry feeds the /evolve skill to improve future runs.