---
title: "Paradox of the Active User"
source: "/reference/paradox-of-the-active-user"
description: "People often prefer to begin doing the task immediately rather than first investing time in manuals or complete instruction."
---
# Paradox of the Active User

People often prefer to begin doing the task immediately rather than first investing time in manuals or complete instruction.



### Principle

People often prefer to begin doing the task immediately rather than first investing time in manuals or complete instruction.

### Why it matters

Users are goal-driven. They frequently learn by acting, observing feedback, and correcting course. Long mandatory tours and documentation-first onboarding conflict with that behavior. Effective onboarding makes essential guidance available at the moment it becomes useful and preserves a path to deeper explanation.

### Deeper design interpretation

People often learn software by trying to accomplish the task rather than by studying the interface in advance. They click, observe feedback, recover, and gradually build competence. Mandatory education that delays meaningful action conflicts with this behavior unless the domain requires prior instruction for safety, consent, or compliance.

The design response is contextual education. Guidance should appear when the relevant decision or unfamiliar concept becomes actionable. It should remain recoverable because users rarely remember a tour shown before they had a reason to understand it.

Layr should measure onboarding against time-to-first-useful-action and the recoverability of help, rather than the amount of educational content delivered.

### What the agent should reason about

Identify where the user can first produce meaningful value. Determine whether instruction before that point is necessary. If a tutorial is skippable, check whether users can access it later. Distinguish required safety education from marketing walkthroughs or feature tours.

The agent should first consider improving the interface itself before recommending more tooltip layers.

### Common failure patterns

- Long mandatory tours block an otherwise understandable task.
- Tooltips explain ambiguous controls instead of fixing the controls.
- Guidance disappears permanently after dismissal.
- Empty states teach features without offering a direct action.
- Users must configure advanced features before experiencing basic value.

### Audit questions

- How soon can the user accomplish something meaningful?
- Which instructions are required before action, and why?
- Can users recover help later when context makes it useful?
- Is documentation compensating for unclear interaction design?

### Example agent finding

> **Medium — First-run setup blocks the product behind 11 tooltip steps.** Most steps describe controls that are already labeled, and none are safety-critical. Allow users to enter the workspace immediately, attach advanced guidance to the relevant controls, and keep the walkthrough accessible from Help.

### Agent directive

> Design for immediate productive action. Teach in context and keep guidance recoverable instead of requiring users to consume it all up front.

### Apply this when

- Onboarding, setup, new feature education, empty states, complex editors, imports, and first-run dashboards.

### Observable signals

- A mandatory tour blocks access to an otherwise understandable product.
- Users must read several screens before they can create or explore anything.
- Critical guidance disappears permanently after dismissal.
- Tooltips explain controls that could be self-evident through label and structure.
- Documentation is used to compensate for ambiguous core interaction.

### Recommended actions

- Provide a meaningful first action quickly.
- Attach guidance to the moment of need.
- Make tutorials skippable when safe and accessible later.
- Use examples, templates, and reversible exploration to support learning by doing.
- Improve the interface itself before adding explanatory overlays.

### Do not over-apply

Some domains require training, consent, or safety instruction before action. Do not bypass mandatory guidance where errors carry serious consequences.

### Example

**Weak:** A project tool forces every new user through twelve tooltip steps before allowing them to create a project.

**Stronger:** The user can create a first project immediately, with contextual guidance appearing when an unfamiliar advanced capability is reached.

### Evaluation notes

- **Default severity:** Medium for activation friction; high when users cannot recover necessary guidance.
- **Typical confidence:** High for blocking onboarding; medium for learning behavior.
- **Primary evidence:** Onboarding flow, dismissibility, help recovery, first useful action, task consequence.
- **Related rules:** Jakob's Law, Mental Model, Goal-Gradient Effect, Cognitive Load

### References

- [Laws of UX — Paradox of the Active User](https://lawsofux.com/paradox-of-the-active-user/)
- [Laws of UX — Onboarding for Active Users](https://lawsofux.com/articles/2024/onboarding-for-active-users/)

## Related rules

- [Jakob's Law](/__layr/pages/reference/jakobs-law.md)
- [Mental Model](/__layr/pages/reference/mental-model.md)
- [Goal-Gradient Effect](/__layr/pages/reference/goal-gradient-effect.md)
- [Cognitive Load](/__layr/pages/reference/cognitive-load.md)

## Agent guidance

Review criteria, the finding contract a report must use, and worked examples.

Established principle; Layr interpretation and agent guidance. Category: Decision, Simplicity & Familiarity.

## Retrieve
- Canonical page: https://layr.design/reference/paradox-of-the-active-user
- Markdown for agents: https://layr.design/__layr/pages/reference/paradox-of-the-active-user.md
- Reference map: https://layr.design/llms.txt
- Route index: https://layr.design/__layr/routes.toon

## Rule object
```yaml
rule:
  id: "paradox-of-the-active-user"
  title: "Paradox of the Active User"
  category: "Decision, Simplicity & Familiarity"
  origin: established
  canonical_url: "https://layr.design/reference/paradox-of-the-active-user"
  principle: "People often prefer to begin doing the task immediately rather than first investing time in manuals or complete instruction."
  directive: "Design for immediate productive action. Teach in context and keep guidance recoverable instead of requiring users to consume it all up front."
  applies_when:
    - "Onboarding, setup, new feature education, empty states, complex editors, imports, and first-run dashboards."
  observable_signals:
    - "A mandatory tour blocks access to an otherwise understandable product."
    - "Users must read several screens before they can create or explore anything."
    - "Critical guidance disappears permanently after dismissal."
    - "Tooltips explain controls that could be self-evident through label and structure."
    - "Documentation is used to compensate for ambiguous core interaction."
  audit_questions:
    - "How soon can the user accomplish something meaningful?"
    - "Which instructions are required before action, and why?"
    - "Can users recover help later when context makes it useful?"
    - "Is documentation compensating for unclear interaction design?"
  recommended_actions:
    - "Provide a meaningful first action quickly."
    - "Attach guidance to the moment of need."
    - "Make tutorials skippable when safe and accessible later."
    - "Use examples, templates, and reversible exploration to support learning by doing."
    - "Improve the interface itself before adding explanatory overlays."
  avoid_when:
    - "Some domains require training, consent, or safety instruction before action. Do not bypass mandatory guidance where errors carry serious consequences."
  common_failure_patterns:
    - "Long mandatory tours block an otherwise understandable task."
    - "Tooltips explain ambiguous controls instead of fixing the controls."
    - "Guidance disappears permanently after dismissal."
    - "Empty states teach features without offering a direct action."
    - "Users must configure advanced features before experiencing basic value."
  evidence_types:
    - "Onboarding flow"
    - "dismissibility"
    - "help recovery"
    - "first useful action"
    - "task consequence"
  default_severity: "Medium for activation friction; high when users cannot recover necessary guidance."
  typical_confidence: "High for blocking onboarding; medium for learning behavior."
  related_rules:
    - { id: "jakobs-law", title: "Jakob's Law", url: "https://layr.design/reference/jakobs-law" }
    - { id: "mental-model", title: "Mental Model", url: "https://layr.design/reference/mental-model" }
    - { id: "goal-gradient-effect", title: "Goal-Gradient Effect", url: "https://layr.design/reference/goal-gradient-effect" }
    - { id: "cognitive-load", title: "Cognitive Load", url: "https://layr.design/reference/cognitive-load" }
```

## What to reason about
Identify where the user can first produce meaningful value. Determine whether instruction before that point is necessary. If a tutorial is skippable, check whether users can access it later. Distinguish required safety education from marketing walkthroughs or feature tours. The agent should first consider improving the interface itself before recommending more tooltip layers.

## Routing
Route a review here when the user must choose between alternatives, learn an unfamiliar control, navigate competing actions, or configure a system before reaching value. Inspect the structure of the decision before recommending fewer options.

## Review procedure
For every finding:
1. Identify the exact component, state, route, or interaction.
2. State the observable evidence.
3. Name the principle that applies.
4. Explain the user consequence in the current context.
5. Estimate severity from the consequence, frequency, and reversibility.
6. Recommend the smallest change that addresses the issue while preserving the product's existing design system.
7. Lower confidence when intent, frequency, audience, device, or product constraints must be inferred.
8. Do not produce generic advice such as "improve hierarchy" or "make this clearer" without specifying what is wrong and why.

## Finding contract — emit exactly this shape
```yaml
finding:
  rule_id: string
  location: string
  evidence:
    - observable fact
  impact: string
  severity: low | medium | high | critical
  confidence: low | medium | high
  recommendation:
    change: string
    rationale: string
    preserve:
      - existing design-system behavior
      - valid product constraints
```

## Example finding for this rule
Medium — First-run setup blocks the product behind 11 tooltip steps. Most steps describe controls that are already labeled, and none are safety-critical. Allow users to enter the workspace immediately, attach advanced guidance to the relevant controls, and keep the walkthrough accessible from Help.

## Code reference

The same principle as markup. Compare the structure, not the class names.

```html
<!-- weak -->
<div class="example-ui example-ui-weak">
  <div class="scene-chrome">
    <span class="scene-chrome-app">Projects</span>
    <span class="scene-chrome-view">Welcome</span>
  </div>
  <div class="scene-body">
    <div class="scene-blocked">
      <div class="scene-blocked-under">
        <span class="scene-buried-title">Your projects</span>
        <span class="scene-action">New project</span>
        <div class="scene-row scene-row-muted">
          <span class="scene-meta">Atlas redesign</span>
        </div>
      </div>
      <div class="scene-coach">
        <span class="scene-meta">Step 1 of 12</span>
        <span class="scene-coach-title">This is the project sidebar</span>
        <div class="scene-row">
          <span class="scene-meta">Skip unavailable</span>
          <span class="scene-action scene-action-primary">Next tip</span>
        </div>
      </div>
    </div>
    <span class="scene-note">12 mandatory steps before the first project can exist</span>
  </div>
</div>
```

```html
<!-- stronger -->
<div class="example-ui example-ui-strong">
  <div class="scene-chrome">
    <span class="scene-chrome-app">Projects</span>
    <span class="scene-chrome-view">Your projects</span>
  </div>
  <div class="scene-body">
    <div class="scene-panel">
      <span class="scene-panel-title">Your projects</span>
      <span class="scene-action scene-action-primary">New project</span>
      <div class="scene-row">
        <span>Atlas redesign</span>
        <span class="scene-meta">Updated today</span>
      </div>
      <div class="scene-hint">
        <span class="scene-hint-label">Field mapping</span>
        <span>Explained the first time you open an import.</span>
      </div>
      <span class="scene-note">Value first · guidance arrives where it applies</span>
    </div>
  </div>
</div>
```

```css
/* declarations these studies depend on */
.example-ui { display: grid; grid-template-rows: auto minmax(0, 1fr); min-width: 0; min-height: 17rem; overflow: hidden; border: var(--border-thin) solid var(--color-border-strong); background: var(--color-background); color: var(--color-text); font-size: var(--text-xs); line-height: var(--leading-snug); }
.example-ui .scene-chrome { display: flex; flex-wrap: wrap; align-items: baseline; gap: var(--space-1) var(--space-2); padding: var(--space-2) var(--space-3); border-bottom: var(--border-thin) solid var(--color-border-strong); background: var(--color-surface); }
.example-ui .scene-chrome-app { font-size: var(--text-2xs); font-weight: 600; letter-spacing: var(--tracking-label); text-transform: uppercase; }
.example-ui .scene-chrome-view { color: var(--color-text-tertiary); font-size: var(--text-2xs); }
.example-ui .scene-body { display: grid; align-content: start; gap: var(--space-3); min-width: 0; padding: var(--space-3); }
.example-ui .scene-body:has(> .scene-panel:only-child) { align-content: stretch; }
.example-ui .scene-panel { display: grid; align-content: start; justify-items: start; gap: var(--space-2); min-width: 0; padding: var(--space-3); border: var(--border-thin) solid var(--color-border-strong); background: var(--color-surface-raised); }
.example-ui .scene-panel-title { font-size: var(--text-sm); font-weight: 600; letter-spacing: var(--tracking-heading); }
.example-ui .scene-row { display: flex; flex-wrap: wrap; justify-content: space-between; align-items: center; gap: var(--space-1) var(--space-2); width: 100%; min-width: 0; padding-block: var(--space-1); }
.example-ui .scene-panel > .scene-row + .scene-row { border-top: var(--border-thin) solid var(--color-border-subtle); }
.example-ui .scene-row-muted { color: var(--color-text-tertiary); }
.example-ui .scene-meta { color: var(--color-text-tertiary); font-size: var(--text-2xs); }
.example-ui .scene-note { width: 100%; padding-top: var(--space-2); border-top: var(--border-thin) solid var(--color-border-subtle); color: var(--color-text-tertiary); font-family: var(--font-mono); font-size: var(--text-2xs); line-height: var(--leading-snug); }
.example-ui .scene-action { display: inline-flex; align-items: center; justify-content: center; min-height: var(--space-8); padding-inline: var(--space-3); border: var(--border-thin) solid var(--color-border-strong); border-radius: var(--radius-xs); background: var(--color-surface-raised); color: var(--color-text); font-size: var(--text-xs); font-weight: 550; white-space: nowrap; }
.example-ui .scene-action-primary { border-color: var(--color-primary-bg); background: var(--color-primary-bg); color: var(--color-primary-text); }
.example-ui .scene-buried-title { font-size: var(--text-sm); font-weight: 600; }
.example-ui .scene-blocked { position: relative; display: grid; gap: var(--space-2); width: 100%; padding: var(--space-2); background: var(--color-backdrop); }
.example-ui .scene-blocked-under { display: grid; justify-items: start; gap: var(--space-2); opacity: 0.35; }
.example-ui .scene-coach { display: grid; justify-items: start; gap: var(--space-2); padding: var(--space-3); border: var(--border-thin) solid var(--color-border-strong); border-radius: var(--radius-sm); background: var(--color-surface-raised); box-shadow: var(--shadow-floating); }
.example-ui .scene-coach-title { font-size: var(--text-sm); font-weight: 600; }
.example-ui .scene-hint { display: grid; justify-items: start; gap: var(--space-1); width: 100%; padding: var(--space-2); border-left: 2px solid var(--color-border-strong); background: var(--color-surface); color: var(--color-text-secondary); }
.example-ui .scene-hint-label { font-weight: 600; }
.example-ui { min-height: 15rem; }

/* resolved values */
:root {
  --border-thin: 1px;
  --font-mono: "Geist Mono", "SFMono-Regular", Consolas, "Liberation Mono", monospace;
  --leading-snug: 1.35;
  --radius-sm: 4px;
  --radius-xs: 2px;
  --shadow-floating: 0 1px 2px rgb(17 17 15 / 5%), 0 8px 24px rgb(17 17 15 / 8%);
  --space-1: 0.25rem;
  --space-2: 0.5rem;
  --space-3: 0.75rem;
  --space-8: 2rem;
  --text-2xs: 0.6875rem;
  --text-sm: 0.875rem;
  --text-xs: 0.75rem;
  --tracking-heading: -0.025em;
  --tracking-label: 0.06em;
}
```

## Weak vs stronger
- Weak: A project tool forces every new user through twelve tooltip steps before allowing them to create a project.
- Stronger: The user can create a first project immediately, with contextual guidance appearing when an unfamiliar advanced capability is reached.

## Reporting rules
- Report only what the interface shows as observable evidence; phrase psychological or motivational effects as possible consequences.
- Returning no finding is a valid result when evidence is insufficient.
