name: usability-testing
# description: routing-facing summary of when this skill activates and what it covers.
description: "Use when observing representative real users attempting realistic tasks on a prototype or live product to surface usability issues: moderated or unmoderated, remote or in-person, concurrent or retrospective think-aloud, task scenarios, participant screening, tree/first-click testing for IA findability questions, pilot runs, severity rating, sample sizing by claim type, and ethical recording/consent. Do NOT use for automated test suites, code coverage, CI pipelines, unit/integration testing, load testing, or replacing participants with AI/synthetic users; those are engineering verification or synthetic-analysis concerns, not human-behavior observation."
# license: SPDX-compatible license identifier for the skill content.
license: CC-BY-4.0
# metadata: Skill Metadata Protocol fields encoded under Agent Skills-compatible frontmatter.
metadata:
# === v8 Classification (subject + public; polyhierarchy via subjects[]) — see ADR-0017 ===
# subject: primary browse shelf — what the skill teaches. One of twelve closed values:
# backend-engineering / frontend-engineering / software-architecture / data-engineering / agent-ops / ai-engineering /
# quality-assurance / design / reasoning-strategy / software-engineering-method / knowledge-organization / product-domain.
subject: design
# public: publishability/private-data gate. Boolean.
# true = publishable/shareable; false = private and excluded from public export.
# Project anchoring is carried separately by non-empty `project[]` plus `grounding`.
public: true
# scope: free-text PRD-style statement of what the skill teaches and what it excludes.
# (v8 required; not an enum). Mirrors Coverage + Do NOT Use When at frontmatter level.
scope: "Observing representative real users attempting realistic tasks on a prototype or live product to surface usability issues. Covers moderated and unmoderated studies, remote and in-person delivery, concurrent and retrospective think-aloud, neutral moderation (Boren & Ramey speech-communication), task scenarios and task-writing anti-patterns, representative-participant recruiting and screening (per segment), tree testing and first-click testing for IA/findability questions, pilot runs, informed consent and recording ethics, severity rating (frequency × impact × persistence), claim-typed sample sizing per Nielsen/Landauer with Faulkner per-round variance, quantitative complements (task success with small-sample confidence intervals, SEQ, SUS, UMUX-Lite, NASA-TLX), assistive-technology user evaluation (complements, never proves, WCAG conformance), and the AI/synthetic-user boundary (AI can prepare or analyze a study but does not replace observing real users). Portable across any product under evaluation; principle-grounded, not repo-bound. Excludes automated test suites, code coverage, CI/load/unit/integration testing (testing-strategy), pre-artifact generative user research (user-research), building the artifact (prototyping), statistical benchmarking without an adequately powered design, pure WCAG conformance audit (a11y), post-hoc synthesis of a completed corpus (research-synthesis), and AI/synthetic users as substitutes for real participants."
# stability: lifecycle marker. One of:
# experimental (active development) / stable (production-ready) /
# frozen (no further changes expected) / deprecated.
# When `deprecated`, schema's allOf REQUIRES `superseded_by: <real-skill-name>`.
stability: experimental
# keywords: semantic phrases for fuzzy router activation. v8 cap: max 10.
# Keep terms a user would actually type when starting a task in this skill's domain.
keywords: ["think aloud protocol","task scenario","moderated usability test","unmoderated test","severity rating","five user rule","formative testing","summative testing","tree testing","first-click testing"]
# triggers: explicit-match activation phrases the router fires on literally.
# Use when label-based routing is intended; usually keywords + examples are enough.
triggers: ["usability test","think aloud","test this prototype","task scenarios","test with users","synthetic users for usability","tree testing","first-click testing"]
# examples: 2-5 realistic user prompts the skill SHOULD activate for.
# Written in the user's voice. Improves retrieval recall beyond keywords alone.
examples: ["Write three task scenarios for a usability test of this onboarding flow.","How many participants do I need for a formative round on this prototype?","Review my moderator script for neutrality and leading prompts.","Rate the severity of these eight usability findings using Nielsen's scale.","Can we use AI synthetic users instead of recruiting real participants for this usability test?"]
# anti_examples: near-miss prompts that should route ELSEWHERE.
# Pair with relations.suppresses (or legacy boundary alias) to name the confusable territory's owner.
anti_examples: ["Add unit tests for the order-total calculation function.","Set up the CI pipeline for the new repo.","Run a load test against the checkout API.","Run a card sort to design the navigation hierarchy and labels for this site.","Cluster the findings from ten completed user sessions into themes.","Audit this page for WCAG 2.1 Level AA conformance."]
# relations: typed graph edges to sibling skills. Current fields:
# related (adjacency for browse / co-routing expansion) /
# suppresses (exclude listed skills from co-routing when THIS skill wins; write reason
# as "I own this exclusively over X", not "use X instead") /
# boundary (DEPRECATED alias of suppresses, retained for unmigrated skills) /
# verify_with (cross-check; co-loaded as one-hop expansion) /
# depends_on (composition; transitive — A→B→C loads all three) /
# broader / narrower (SKOS-style generalization) /
# disjoint_with (mutual exclusion for incompatible ownership).
# NOTE: testing-strategy is kept in `related` (NOT `suppresses`): it is cross-domain
# (subject quality-assurance), and skill-lint Check 5c flags a cross-domain suppresses
# edge as a mis-modeled distinction. The "test"-word confusion is guarded by the hard
# anti_examples (unit/CI/load) + the Do NOT Use When row instead.
relations: "{\"related\":[\"prototyping\",\"user-research\",\"research-synthesis\",\"design-thinking\",\"testing-strategy\",\"a11y\",\"information-architecture\"],\"verify_with\":[\"a11y\"]}"
# === Grounding (universal — external method literature; no project[] anchor) ===
grounding:
subject_matter: "Portable usability-testing method: real-participant task observation, concurrent/retrospective think-aloud protocols, task design, participant screening, remote/unmoderated tooling, tree and first-click testing for IA/findability questions, severity triage, quantitative complements, accessibility user evaluation, consent/ethics, and AI/synthetic-user boundaries"
grounding_mode: universal
truth_sources:
- path: "https://www.nngroup.com/articles/why-you-only-need-to-test-with-5-users/"
note: "Grounds the classic Nielsen/Landauer formative 5-user problem-discovery rule and diminishing-returns rationale."
- path: "https://www.nngroup.com/articles/how-many-test-users/"
note: "Grounds the qualitative recommendation to test small rounds iteratively rather than one large formative round."
- path: "https://measuringu.com/specific-sample-sizes-in-problem-discovery-studies/"
note: "Grounds the caveat that problem-discovery sample size depends on problem probability and desired discovery rate."
- path: "https://www.nngroup.com/articles/summary-quant-sample-sizes/"
note: "Grounds the distinction between small qualitative formative studies and larger quantitative studies, including the common ~40-participant recommendation."
- path: "https://link.springer.com/article/10.3758/BF03195514"
note: "Grounds Faulkner's 60-user resampling evidence: five-user sets varied widely (55%-99%) in problem discovery, while larger sets raised the worst-case floor (~80% at 10, ~95% at 20)."
- path: "https://measuringu.com/article/estimating-completion-rates-from-small-samples-using-binomial-confidence-intervals-comparisons-and-recommendations/"
note: "Grounds Sauro and Lewis's adjusted-Wald recommendation for small-sample completion-rate confidence intervals."
- path: "https://www.nngroup.com/articles/task-scenarios-usability-testing/"
note: "Grounds goal-framed task scenarios and avoiding feature-leading task wording."
- path: "https://www.nngroup.com/articles/better-usability-tasks/"
note: "Grounds task-writing anti-patterns such as asking what users would do instead of having them perform the task."
- path: "https://www.nngroup.com/articles/thinking-aloud-the-1-usability-tool/"
note: "Grounds think-aloud as a core usability method, including the representative-users/tasks/shut-up discipline."
- path: "https://doi.org/10.1109/47.867942"
note: "Grounds Boren and Ramey's speech-communication framing of think-aloud practice and pragmatic non-leading channel maintenance."
- path: "https://forskning.ruc.dk/en/publications/concurrent-or-retrospective-thinking-aloud-in-usability-tests-a-m/"
note: "Grounds the concurrent vs retrospective think-aloud tradeoff from Hertzum's 2024 meta-analytic review."
- path: "https://www.nngroup.com/articles/navigation-ia-tests/"
note: "Grounds tree testing and click/first-click testing as specialized evaluative methods for IA, navigation, and findability questions."
- path: "https://www.nngroup.com/articles/usability-checklist/"
note: "Grounds facilitator-guide mechanics, consent, recordings, task-by-task delivery, and managing expectations."
- path: "https://www.nngroup.com/articles/unmoderated-usability-testing/"
note: "Grounds unmoderated study steps, limitations, pilot testing, and suitability for live/highly functional artifacts."
- path: "https://www.nngroup.com/articles/unmoderated-user-testing-tools/"
note: "Grounds current remote unmoderated-tool capabilities: screen/voice recordings, transcripts, clips, task-based behavior."
- path: "https://www.nngroup.com/articles/how-to-rate-the-severity-of-usability-problems/"
note: "Grounds Nielsen's 0-4 severity scale and severity as a composite of frequency, impact, and persistence."
- path: "https://www.nngroup.com/articles/measuring-perceived-usability/"
note: "Grounds SUS, SEQ, NASA-TLX, and the distinction between post-task and post-test subjective measures."
- path: "https://www.nngroup.com/articles/success-rate-the-simplest-usability-metric/"
note: "Grounds task success as a simple usability metric and a quantitative complement to qualitative observation."
- path: "https://measuringu.com/umux-lite/"
note: "Grounds UMUX-Lite as a two-item post-test perceived-usability measure correlating strongly with SUS."
- path: "https://www.nngroup.com/articles/screening-participants/"
note: "Grounds representative participant screening and why 'just anyone' invalidates findings."
- path: "https://www.nngroup.com/articles/informed-consent/"
note: "Grounds informed consent, participant understanding, voluntary participation, and recording/data-use ethics."
- path: "https://www.w3.org/WAI/test-evaluate/involving-users/"
note: "Grounds combining usability evaluation with disabled participants and WCAG conformance, and explains why user testing alone is not an accessibility conformance audit."
- path: "https://www.nngroup.com/articles/synthetic-users/"
note: "Grounds the AI/synthetic-user boundary: useful for hypotheses and preparation, not a replacement for real-user research or final decisions."
- path: "https://help.usertesting.com/hc/en-us/articles/13268691111453-AI-insight-summary"
note: "Grounds current vendor AI capabilities that summarize real participant verbal, text, and behavioral data, and the 'view source' trace flow that supports AI-as-analysis-aid, not participant replacement."
- path: "https://www.amazon.science/publications/uxagent-an-llm-agent-based-usability-testing-framework-for-web-design"
note: "Grounds current upstream LLM-agent simulation work (UXAgent) and its positioning as pre-human-study support rather than settled replacement."
failure_modes:
- five_user_rule_applied_to_summative_or_benchmark_claim
- sample_size_not_segmented_by_distinct_user_group_or_task_scope
- bare_small_sample_percent_reported_as_statistical_proof
- small_n_completion_rate_reported_without_confidence_interval
- participants_not_representative_or_unscreened
- task_scenario_names_the_feature_path_or_ui_label
- moderator_rescues_explains_defends_or_leads
- tree_or_first_click_test_reported_as_full_interactive_usability_evidence
- unmoderated_used_for_early_brittle_or_emotion_heavy_prototype_without_probe_or_recovery
- no_pilot_run_before_real_participants
- recording_without_informed_consent_or_unclear_data_use
- severity_rated_by_vibes_without_impact_frequency_or_persistence_evidence
- accessibility_user_evaluation_misreported_as_wcag_conformance
- synthetic_users_or_llm_agents_presented_as_real_user_evidence
- ai_summary_treated_as_finding_without_source_trace_to_recording_or_notes
- all_confirming_result_accepted_without_task_or_moderation_audit
evidence_priority: general_knowledge_first
# === Understanding fields (when comprehension_state: present) ===
# mental_model: the primitives of the concept and how they relate. One paragraph.
mental_model: |
Usability testing is empirical observation of people performing tasks against an artifact, not opinion: you watch real people attempt realistic task scenarios and record where their mental model diverges from the design. Its primitives are the artifact, the study purpose, representative participants, realistic task scenarios, the participant's mental model, the moderator or unmoderated platform, the observation record, usability problems, severity, and the claim the team wants to make. The core instrument is the think-aloud protocol, which externalizes reasoning at the moment an obstacle occurs — run either concurrently (narrate while working, the default) or retrospectively (narrate while reviewing a recording, when concurrent speech would distort a cognitively demanding task). The moderator's job is to be deliberately uninteresting — frame goals, stay neutral, keep the channel open with minimal non-leading backchannel, let silence and struggle sit, and never rescue or defend — because the struggle is the finding and explaining the design destroys it. Sample size is tied to the claim's purpose and is a noisy average, not a guarantee: a FORMATIVE test asks "what breaks and why?" and learns a lot from small repeated rounds (~5 per homogeneous segment per discrete task) while accepting that any one round of five has high variance; a SUMMATIVE/benchmark test asks "how well, compared with what?" and needs a larger statistical design. IA-focused variants — tree testing and first-click testing — narrow the artifact so the claim is about findability or first-path expectations, not the whole interactive experience. Findings are triaged by severity (a composite of frequency, impact, and persistence) rather than listed flat, and quantitative instruments (task success with confidence intervals, SEQ, SUS) complement the observation when a number is needed. AI and synthetic users can prepare studies and summarize real sessions, but they do not supply the surprising off-path human behavior that makes usability testing valuable.
# purpose: the problem this concept solves and why the field exists. One paragraph.
purpose: |
Designers and engineers cannot reliably predict where users will struggle: the mental models that make a design feel obvious to its creators are exactly the models a fresh user lacks. Usability testing exists to close that gap with direct evidence — replacing "I think users will understand this" with "we watched representative users try, here is what happened, and here is what must change first." It catches obstacles early enough to fix cheaply (formative rounds against prototypes), reveals when a task or artifact only works for insiders, prevents teams from shipping designs that only make sense to the people who built them, and produces severity-ranked findings the team can triage. Done honestly, it is humbling by design: a session that confirms the design entirely is suspect, because it usually means the tasks were too easy or the moderator was unintentionally helping. Modern tooling makes sessions easier to recruit, record, transcribe, summarize, and run remotely, but the core evidence remains observed human behavior — which is also why AI-generated "synthetic users" cannot substitute for it: a statistical model predicts the likely path, while the value of a usability test is the surprising, off-path behavior a real human produces that no model can reliably anticipate.
# concept_boundary: what this concept is NOT. Distinguishes from adjacent skills by naming
# the MECHANISM that differs, not just the label. Canonical replacement for top-level `boundary`.
concept_boundary: |
This is NOT automated verification of code correctness (testing-strategy owns unit, integration, end-to-end, CI, and load testing), NOT generative discovery of unmet needs before any artifact exists (user-research), NOT building the artifact to test (prototyping — build first, then test), NOT statistical benchmarking across a large population (that needs summative methods or controlled experimentation, not the 5-user formative rule), NOT a specification-conformance audit (a11y owns WCAG/ARIA conformance; usability testing with disabled participants complements it with empirical observation but is not the conformance check), NOT designing or building an information structure (information-architecture owns card sorting and IA generation; usability testing's tree and first-click tests EVALUATE an existing structure against real attempts), NOT extracting themes from a corpus of completed sessions (research-synthesis), NOT expert inspection against heuristics with no users in the room (heuristic evaluation is expert judgment, not human observation), and NOT a simulation of users by an AI model (synthetic users predict the statistically likely path and miss the surprising real-human behavior that is the point of the test — AI can assist the loop but does not replace observing real users). It owns the moderated/unmoderated observation of representative real users attempting tasks to surface usability issues, preserving trustworthy evidence, and triaging usability problems.
# analogy: one-sentence metaphor preserving the core mechanism.
analogy: "A usability test is to a design what a flight check with a new pilot is to a cockpit layout — you do not ask the designers whether the controls are intuitive; you put someone unfamiliar in the seat, give them a goal, and watch which switch they reach for, because the moment they reach for the wrong one is the finding, and a helpful instructor pointing at the right switch erases the very evidence you came for."
# misconception: the wrong mental model people bring; corrected explicitly.
misconception: |
The most damaging misconception is that the 5-user rule means "5 users is always enough to test anything." The corrected model: 5 users surfaces ~85% of major problems only as a long-run AVERAGE, only per homogeneous segment, per discrete task, and only for FORMATIVE diagnostic testing — Faulkner's 2003 resampling study showed individual sets of 5 ranged from catching 55% to 99% of problems, so a single round is noisy; 10 users raised the worst-case floor to ~80% and 20 to ~95%. They do not prove a benchmark, a conversion lift, statistical significance, or accessibility conformance — those need a separate, larger statistical design (often dozens of participants, commonly cited around 40). A second common misconception is that a smooth session where the user succeeds and the moderator answered their questions is a good test; in fact a moderator who explains the design after a participant gets stuck has destroyed the evidence, and an all-confirming session usually means the tasks were too easy, the participants were mismatched, or the moderator helped. A third, newer misconception is that AI "synthetic users" can stand in for real participants; they are useful for piloting a script, drafting hypotheses, or summarizing real session data, but presenting their simulated output as real-user findings is dishonest and misses the off-path behavior real users produce. Good moderation is neutral, patient, and willing to let the participant struggle.
Usability Testing
Concept of the skill
Usability testing is the evaluative research practice of watching representative real people attempt realistic tasks on a prototype or product to surface the obstacles they encounter — making it empirical observation rather than expert opinion. Its core instrument is the think-aloud protocol (Ericsson & Simon), where participants narrate their reasoning so the divergence between their mental model and the design becomes visible at the moment it happens. Sessions are built around task scenarios that state a goal without prescribing steps ("find out how much you owe in taxes this quarter"), run by a moderator whose discipline is neutrality: frame the goal, prompt only with open questions, let silence and struggle sit, and never rescue or defend the design.
The craft has four hard gates. First, the artifact must exist at a fidelity where a real person can attempt the task. Second, the participant must match the study's target audience closely enough that the result transfers. Third, the task must be goal-framed rather than path-framed: "find out how much you owe this quarter," not "click Tax Summary, then View Details." Fourth, the claim type must match the study design: small formative rounds are excellent for discovering and diagnosing problems; summative benchmark claims require larger samples, metrics, and statistical justification.
Sample size is governed by purpose — the Nielsen/Landauer 5-user rule (~85% of major problems per homogeneous segment, per discrete task) holds for formative, diagnostic, iterative testing, but it is a long-run average with real per-round variance (Faulkner 2003), and summative benchmark claims require much larger statistical samples; conflating the two is a classic, invalidating error. Findings are triaged by Nielsen's 0–4 severity scale — itself a composite of frequency, impact, and persistence — complemented when needed by quantitative instruments (task success reported with a small-sample confidence interval, SEQ, SUS or UMUX-Lite). Current tooling — remote moderated sessions, unmoderated platforms, automatic transcripts, AI-assisted highlights, and LLM-agent simulations — has changed the logistics, not the epistemology: it can reduce operational cost, but it does not replace observing real humans. (For the standard practitioner reference behind these mechanics, see Rubin & Chisnell, Handbook of Usability Testing, 2008.)
Coverage
Usability testing covers session planning, participant selection, task design, moderation or unmoderated setup, observation, severity triage, and claim-appropriate reporting.
Study purpose and method choice
| Purpose | Strong default | What it can claim | Watch out for |
|---|
| Find major usability problems early | Moderated formative test, often ~5 participants per homogeneous segment/task | Diagnostic findings and redesign priorities | Does not prove success rate, conversion lift, or statistical significance |
| Quickly check a simple, stable flow at scale | Remote unmoderated test with a pilot run | Behavioral recordings, task-success patterns, frequent friction | Weak for early brittle prototypes, emotional work, or unexpected follow-up |
| Evaluate IA, navigation labels, or first-path cues | Tree testing for hierarchy/findability; first-click testing for static-screen entry points | Directness, destination choice, first-click distribution, success patterns | Does not explain full interactive behavior; escalate to moderated testing when follow-up behavior matters |
| Compare designs or benchmark performance | Quantitative/summative usability study | Metrics such as success rate, time on task, SUS/SEQ, with confidence intervals | Usually needs many more participants, often dozens (commonly ~40), not five |
| Explore accessibility barriers with disabled users | Usability evaluation with relevant disabled participants and assistive technologies | Lived barriers and task evidence for the included user groups | Must be combined with WCAG conformance evaluation; it is not itself conformance |
| Prepare research with AI/synthetic users | Synthetic prompts, study-design dry runs, AI-assisted transcript review of real sessions | Hypotheses and analysis aids | Never report simulated users as real participants or final validation |
Recruiting and screening participants
Sample size is only half the question; who you recruit decides whether the findings transfer to your real users. Participants must be representative of the actual user population for the task — recruit from the segments who will really use the product, not whoever is convenient (colleagues, friends, or other designers carry insider mental models and invalidate the test). Write a screener: a short set of qualifying questions on the behaviors, domain familiarity, and tool experience that define each segment, plus disqualifiers (e.g. people who work in UX or for a competitor). When the product genuinely serves distinct segments (first-time vs. power users, administrators vs. end users, mobile-only vs. desktop, assistive-technology users, or different roles), treat each as a separate cohort and apply the 5-user heuristic per segment — one mixed group of five does not cover two segments. Document the realized participant profile, and who was excluded and why, so a reader can judge transferability rather than assuming it.
Task scenarios
Task scenarios state a goal with enough context for the participant to care, while withholding the path the design team hopes they will take ("you want to find out how much you owe in taxes this quarter"). Good scenarios avoid UI labels, feature names, insider language, jokes, offensive or sensitive assumptions, and hypothetical "how would you…" wording. "Find a way to receive upcoming events by email" is stronger than "click Sign up for newsletter"; "find the symptoms of the flu" is stronger than "how would you find the symptoms?" — because the point is observed behavior, not a verbal plan. A task whose wording names the destination has already given away the finding you came to observe.
Think-aloud variants
The classic Ericsson & Simon protocol is concurrent think-aloud (CTA): the participant narrates while performing the task, and the moderator says almost nothing beyond "keep talking." CTA captures reasoning at the moment of struggle but introduces reactivity — narrating can slow users down or change how they work, and some participants fall silent exactly when a task gets hard (the moment you most want to hear). Retrospective think-aloud (RTA) addresses this: the participant works in silence, then narrates while reviewing a recording. RTA removes reactivity and often yields fuller explanations, but it relies on memory, can introduce post-hoc rationalization, and roughly doubles session time. Hertzum's 2024 meta-analytic review (ACM TOCHI) found CTA and RTA surface comparable sets of problems but reveal them differently — choose CTA by default, RTA when the task is too cognitively demanding to narrate live.
Moderation
Moderator neutrality is active discipline. The strict Ericsson & Simon model forbids any acknowledgment (no "mm-hmm," no nodding) to avoid contaminating the cognitive trace. In practice, Boren & Ramey (2000) showed that real usability moderation works better as speech communication — the participant is the primary speaker and the moderator is a listener who keeps the channel open with minimal, non-leading backchannel tokens ("mm-hmm," "keep going," "what are you thinking now?") rather than stony silence, which keeps participants talking without steering them toward an answer. The moderator frames the session, gives tasks one at a time, clarifies the task only when needed, and lets silence sit. They do not teach the interface, defend the design, explain what was intended, praise a path, or rescue a participant as soon as friction appears. Both models agree on the hard rule: if a participant gets stuck, the stuckness is the finding — never explain, defend, or rescue.
Moderated, unmoderated, remote, and in-person
Moderated testing gives richer data because a researcher can notice surprise, ask neutral follow-up, and recover when a prototype glitch or participant misunderstanding would otherwise derail the session; it costs more scheduling effort. Unmoderated testing scales faster because the platform administers tasks asynchronously and records screen, voice, clicks, transcripts, and sometimes clips; it requires more meticulous setup because no human can adapt mid-session. Pick moderated for early, complex, or exploratory flows where probing matters; pick unmoderated for fast validation of a simple, well-scoped flow at volume. A common mature stack pairs one of each. Both are now predominantly remote (moderated over video with screen sharing; unmoderated async on panel-recruiting platforms), though in-person still matters when the environment, device setup, physical product, assistive technology, privacy, or context is part of the behavior being tested. For obvious blockers, the RITE method (Rapid Iterative Testing and Evaluation) fixes a confirmed problem immediately after the participant who hit it, then tests the fix with the next participant — trading a clean fixed-sample comparison for faster convergence on the worst issues.
Tree testing and first-click testing
Beyond task-based observation, two lightweight quantitative methods answer narrower findability questions and are usually run unmoderated at scale. First-click testing measures where users click first to start a task — first-click success correlates strongly with overall task success, so it is a fast signal for whether an entry point or label is discoverable; its key metrics are first-click success and time to first click. Tree testing (reverse card sorting) evaluates an information hierarchy in the abstract, stripped of visual design, by asking users where they would look to find an item — isolating navigation-label and structure problems from layout problems; its key metrics are success and directness (reaching the target without backtracking). Treat their claims narrowly: they can show that people pick the wrong label or miss the expected entry point, but they do not test the full interactive sequence, state changes, error recovery, or emotional reaction. Both are evaluative usability methods; when the question is designing the hierarchy or labels rather than evaluating an attempt, that is adjacent information-architecture work, not this skill.
Sample sizing
The widely-cited Nielsen/Landauer "5-user rule" estimates that 5 users surface ~85% of major usability problems for a homogeneous user group on a discrete task, with steeply diminishing returns afterward. Read it as "small repeated rounds often have the best learning-to-cost ratio," and treat the 85% as a long-run average, not a guarantee for any one round. Faulkner's 2003 study re-sampled sets from a 60-user pool and found individual sets of 5 caught anywhere from 55% to 99% of known problems; raising the sample to 10 lifted the worst-case floor to ~80%, and 20 users to ~95%. The practical reading: 5 is a defensible minimum for a fast formative round, but if a round can only be run once or the cost of missing a major problem is high, 8–12 users buys a meaningfully tighter floor. For problem discovery the real question is what problem probability you need to detect, and with what discovery confidence — rarer problems require more participants.
The rule has further limits: it applies per distinct user segment, per discrete task scope, and to formative (iterative diagnostic) testing — not to summative (benchmark) studies. Summative or quantitative claims need a separate sample-size rationale; many quantitative UX studies need dozens of participants (commonly ~40 under specific assumptions). Do not present "3 of 5" as proof of a population rate.
Severity rating
Findings are organized by a severity rating (Nielsen's 0–4 scale: 0 = not a problem, 1 = cosmetic, 2 = minor, 3 = major, 4 = catastrophic) so the team can triage under time pressure. Severity is not a single gut impression — Nielsen defines it as a composite of three factors: frequency (common or rare?), impact (easy or hard for the user to overcome?), and persistence (a one-time hurdle once learned, or a repeated annoyance?). Rate the factors and combine them, rather than assigning a number by feel; a rare but catastrophic-impact, persistent problem (e.g. a blocker that stops checkout) outranks a frequent cosmetic one. Each finding should carry enough evidence to be falsifiable: task, participant segment, observed behavior, quote or timestamp when available, expected path or mental model, impact, severity, and recommended next step.
Quantitative complements
Qualitative observation is the primary signal, but numbers help when a stakeholder needs one. Task success rate (binary or with partial-success levels) is the most direct behavioral metric — but with the small samples usability tests use, report it as a confidence interval, not a bare percentage: "3 of 5 succeeded" is 60% with a 95% interval roughly spanning 23%–88% (adjusted-Wald method, Sauro & Lewis 2005, which the standard Wald grossly understates at small n), so the point estimate alone overstates certainty. Time on task and error counts measure efficiency. For subjective ease, the Single Ease Question (SEQ) — a 7-point post-task difficulty rating (Sauro & Dumas 2009) — is fast and well-validated; for whole-product perceived usability, the System Usability Scale (SUS) (Brooke 1996) or the two-item UMUX-Lite (Lewis et al., which correlates strongly with SUS) work post-test; NASA-TLX fits complex workload-heavy tasks. Use each at the right scope (SEQ post-task, SUS/UMUX-Lite post-test). Quantitative instruments belong to summative or mixed studies; they do not rescue an underpowered formative round, and a number without the path, hesitation, misinterpretation, or workaround behind it is weak evidence for redesign.
Accessibility and assistive-technology users
Recruiting representative users includes recruiting people with disabilities who use assistive technologies (screen readers, switch access, screen magnification, voice control). The W3C WAI guidance ("Involving Users in Web Projects / Evaluation") is explicit on two points: usability testing with disabled users surfaces real barriers that automated checks and expert review miss, and it does not prove WCAG conformance — a clean session with three screen-reader users is empirical evidence of usability, not a conformance certificate, and does not generalize to all disabled users. Recruit for the relevant disability/AT profiles, set up the participant's technology, make facilities or remote tooling accessible, adapt facilitation style, and report scope precisely (e.g. "two NVDA users, one VoiceOver user, one switch-access user") rather than a vague "we tested with accessibility users," because the specific assistive technology determines which barriers are observable. This complements the a11y skill's conformance audit; it does not replace it (see Do NOT Use When).
Pilot session, consent, and ethics
Always run a pilot session (a dry run with one participant or a colleague) before the real rounds — it catches broken task wording, prototype dead-ends, login/technical failures, misleading follow-up questions, and timing problems while they are still cheap to fix; in an unmoderated study, where no human can adapt mid-session, an un-piloted broken task can corrupt an entire batch. Treat participants ethically: obtain informed consent before recording, explain the purpose and how the recording will be used and stored, make clear the participant is free to stop at any time, and that you are testing the design, not them. Protect the resulting data: de-identify transcripts and recordings where feasible and store sensitive participant data under access control. These are not optional courtesies — a recorded session without consent is an ethics (and often legal) failure.
What NOT to do in a session
The skill also covers session anti-patterns: leading prompts ("don't you think the menu should be here?"), defending the design, explaining how the design "is supposed to work" when the participant gets stuck, praising a particular path, and over-fitting interpretations to a single dramatic finding from one participant.
AI and synthetic users
The upstream-displacement check is clear: a 2024–2025 wave of AI tooling has improved the logistics and analysis around usability testing, but it has not displaced the method. Three honest uses, and one hard line:
- *AI summarization of real session data (verbal transcripts, typed responses, behavioral logs from genuine sessions) is acceptable — but every reported finding must trace back to its evidence* (a specific recording timestamp, transcript line, or clip), not to the model's paraphrase. Vendor "AI insight" summaries that offer a "view source" path into the underlying recording are the supported pattern. An AI summary is a navigation aid into the real data, never a replacement; a finding that cannot be tied to an observed participant moment is not a finding.
- *AI/synthetic users for preparing a study* — drafting task scenarios, piloting a moderator script, generating hypotheses, and running a "synthetic pre-flight" smoke test to catch UI logic errors before expensive human sessions — is a legitimate, labeled aid.
- AI-assisted follow-up during unmoderated walkthroughs is an experimental enhancement, not a primary modality: it can probe for qualitative depth on real participants only when the prompts are neutral and the resulting findings are traceable to participant behavior; reports flag weak new-issue discovery and participant frustration, so treat it as assistive, with human oversight.
The hard line: synthetic users do not replace observing real users, and presenting their output as real-user findings is dishonest (Nielsen Norman Group is explicit on this). The mechanism is the one that justifies the whole skill: a model predicts the statistically likely path, while the value of a usability test is the surprising, off-path behavior a real human produces. Empirical checks bear this out — synthetic users show an over-optimistic completion bias (reporting success real users never achieve), and LLM agents in usability tasks (e.g. the UXAgent CHI 2025 work) follow neat, direct paths while real users wander, second-guess, and abandon. Label synthetic output as synthetic, treat it as a hypothesis, and verify it with real users before any product decision. When a request asks to "use synthetic users instead of real participants," this skill owns the answer — it is the explanation of why direct observation is irreplaceable.
Philosophy of the skill
Usability testing is built on a humbling claim: designers and engineers cannot reliably predict where users will struggle. The mental models that make a design feel obvious to its creators are exactly the models a fresh user lacks, and only direct observation closes that gap. The discipline rejects "I think users will understand this" in favor of "we watched users; here is what happened." Each session that confirms the design entirely is mildly suspicious — either the tasks were too easy or the moderator was unintentionally helping.
The practice is opinionated about moderator behavior. The moderator's job is to be uninteresting — to let the silence sit, to let the participant struggle long enough for the obstacle to become visible, to not rescue. This is hard because the social instinct is to help and the design instinct is to defend. A moderator who explains the design after a participant gets stuck has destroyed the evidence; the obstacle the participant just encountered is the finding, and it cannot be re-observed in that session.
The discipline is also anti-theater. A polished report with no contradictions, no behavioral evidence, no representative participants, and no painful findings is not a successful usability test — it is probably a leading script, a weak task set, a mismatched sample, or a moderator who rescued the design. Useful testing produces specific changes the team would not have made from opinion alone.
Verification
- The study purpose is explicit: formative problem discovery, unmoderated scale check, IA/findability evaluation, accessibility barrier exploration, or summative benchmark.
- A pilot session was run before the real rounds, and any broken task wording, prototype dead-ends, login/recording/platform issues, or misleading follow-ups it surfaced were fixed first.
- Tasks are written as goals, not as instructions — a participant could complete the task without seeing the design first; "find out how much you owe" not "click the Tax Summary tab and then click View Details" — and they avoid UI labels, feature names, hypothetical wording, and insider language.
- Participants were recruited against a screener that qualifies them as representative of the real user segment (not colleagues or other designers), distinct segments were tested as separate cohorts, and the realized participant profile (and who was excluded and why) is documented.
- Informed consent was obtained before recording; participants know what data is captured, how it will be used, and that they could stop at any time.
- The moderator script contains no leading prompts, praise cues, or defensive explanations; the moderator's most common utterances are "what are you thinking?", non-leading backchannel ("mm-hmm"), and silence.
- The think-aloud variant fits the task: concurrent by default; retrospective when narrating live would interfere with a cognitively demanding task.
- Findings are rated by severity using observed frequency, impact, and persistence — not just listed; the team can identify catastrophic issues distinctly from cosmetic ones, with evidence (task, segment, behavior, quote/timestamp, expected path, recommended step).
- Sample size matches the claim type — ~5 users for formative diagnostic findings is a defensible minimum (with per-round variance acknowledged, and high-risk discovery sized larger); summative or benchmark claims are justified separately with a much larger, statistically powered design.
- Any quantitative claim from a small sample (task success, completion rate) is reported with a confidence interval, not as a bare point estimate.
- Tree-testing and first-click results are labeled as IA/findability or first-path evidence, not as proof that the whole interactive flow works.
- If accessibility was in scope, real assistive-technology users were recruited and their specific AT profiles recorded — and the session is framed as usability evidence, not a WCAG-conformance claim.
- Recordings or detailed notes (timestamps, quotes, clips) preserve specific participant behavior so synthesis works from observation, not from moderator impressions; sensitive data is de-identified or access-controlled.
- If AI/synthetic users were involved, they were used only to prepare or analyze the study — never presented as real-user findings; any AI summary of real session data traces each finding back to a recording, transcript line, or clip.
- At least one finding contradicts a designer or PM expectation; if every finding confirms prior beliefs, audit task difficulty, sample fit, and moderator neutrality.
Do NOT Use When
- The target is automated verification of code correctness — use testing-strategy for unit, integration, end-to-end, CI, and load tests.
- The goal is to discover what users need before any artifact exists — use user-research for generative interviews, contextual inquiry, diary studies, or field observation.
- The artifact has not yet been built or sketched — build a prototype first via prototyping, then test it.
- The question requires statistical significance, conversion lift, A/B comparison, or population benchmarking — use a properly powered quantitative or experimentation method; do not stretch the 5-user formative rule.
- The evaluation is purely about accessibility conformance to a specification — use a11y for WCAG/ARIA conformance review; usability testing complements this with empirical observation of assistive-tech users but is not a conformance audit.
- The task is to design or generate an information hierarchy, navigation labels, or run a card sort to build structure — use information-architecture; usability testing's first-click and tree tests EVALUATE an existing structure against real attempts, they do not design it.
- The team wants tree testing or first-click testing to answer why a full multi-step interaction breaks — use those methods only for the narrower IA, navigation, and first-entry questions, then run moderated usability testing for the rest of the behavior.
- The evaluation is an expert inspection against heuristics with no users in the room — that is heuristic/expert review, a distinct method; usability testing requires real participants.
- The output should be themes from a corpus of completed sessions — move to research-synthesis for affinity mapping and insight extraction.
- The plan is to replace real participants with AI/LLM agents or synthetic users to "validate" a design — this skill owns the explanation of why that is invalid; synthetic users may prepare or analyze a study but cannot stand in for observing real people.
- The work is passive analytics/session-replay mining with no recruited participants and no task scenario — route to analytics/product-instrumentation work, unless the team is converting the insight into a real usability study.