Usability Heuristics skill for Codex

Nielsen-based UX audits with evidence and fixes. Codex scopes the review to a handful of real tasks, walks them in the running app including loading, error and empty states, and logs each problem with location, evidence, the heuristic it breaks, a 0 to 4 severity and a concrete fix. Duplicates are merged, root causes grouped, and the report flags which findings deserve user testing because expert inspection is not user research.

  • Design & UX
  • $usability-heuristics
  • 168 lines
  • 3 files
  • ~1,850 tokens
  • MIT
  • Updated

Install

curl -fsSL codexskills.dev/install.sh \  | sh -s -- usability-heuristics

Installs to ~/.agents/skills/usability-heuristics/ for every project on this machine.

104-line POSIX script. No sudo, no telemetry. Read install.sh

Use it in Codex

Start a prompt with $usability-heuristics, or pick it from /skills. You can also just describe the task: Codex reads the description below and loads the playbook when your request matches.

What Codex reads before loading it

Runs a heuristic evaluation of a web or app interface against Nielsen's ten usability heuristics - scopes the tasks, walks each flow in a real browser or from screenshots, logs every violation with location, evidence, heuristic, 0-4 severity and a concrete fix, merges duplicates and delivers a prioritised findings report. Use when asked for a UX review, usability audit, expert review or heuristic evaluation, or to find why users struggle with a flow before running user testing.

Use it when

  • You need an expert UX review of a flow before or instead of user testing
  • Users drop off in a flow and you want likely causes ranked
  • A redesign needs a baseline list of usability problems
  • Stakeholders want a structured findings report rather than opinions

Use something else when

How to check the result

Every major or catastrophic finding has a screenshot and reproducible steps, and re-walking each task with the proposed fixes removes the friction that was logged.

The mistake it prevents

Evaluating screens without defined tasks, which turns the audit into taste-based comments instead of task-blocking problems.

~/.agents/skills/usability-heuristics/SKILL.md

--- name: usability-heuristics description: Runs a heuristic evaluation of a web or app interface against Nielsen's ten usability heuristics - scopes the tasks, walks each flow in a real… license: MIT ---

A useful heuristic evaluation names specific problems on specific screens, explains which user expectation each one breaks, ranks them by how much they hurt task completion, and gives a fix a designer or engineer can act on. It is expert inspection, not user research: say so in the report, and recommend testing for the findings that matter most.

The ten heuristics (short form)

#HeuristicThe question to ask
H1Visibility of system statusDoes the user always know what is happening and whether their action worked?
H2Match between system and the real worldAre words, icons and order the user’s, not the database’s?
H3User control and freedomCan they undo, cancel, go back, and leave without penalty?
H4Consistency and standardsDo same things look and behave the same, here and on the platform?
H5Error preventionDoes the design stop mistakes before they happen?
H6Recognition rather than recallAre options visible instead of memorised across screens?
H7Flexibility and efficiency of useCan experts go faster (shortcuts, defaults, bulk actions) without hurting novices?
H8Aesthetic and minimalist designDoes every element earn its place, or does noise bury the important parts?
H9Help users recognise, diagnose and recover from errorsDo errors say what went wrong, why, and how to fix it, in plain words?
H10Help and documentationIs help findable, in context, and task-focused when it is needed?

For probe questions and common violation patterns per heuristic, read references/heuristics-checklist.md while walking each screen.

Severity scale

ScoreLabelMeaning
0Not a problemDisagreement only; do not report
1CosmeticFix if time allows
2MinorSlows users or causes hesitation; low priority
3MajorCauses errors or abandonment for many users; fix before next release
4CatastrophicBlocks task completion or causes data/money loss; fix now

Rate severity from three factors: frequency (how many users hit it), impact (how hard to overcome), persistence (once or every time). Note the reasoning in one line.

Workflow

  • Agree scope: product area, 3-6 key tasks, target user, platform and viewport.
  • Get access: a running local or staging build, seeded test data, a test account.
  • First pass: walk each task end to end as the target user, noting friction.
  • Second pass: inspect each screen against H1-H10 with the checklist.
  • Log every finding with evidence (screenshot path, URL, steps).
  • Merge duplicates, assign severity, write fixes.
  • Write the report, highest severity first; list strengths and limits.

1. Scope

Product area: <e.g. team billing settings>
Target user: <role, experience level, device>
Tasks:
1. Upgrade from Free to Team plan
2. Add a seat and invite a colleague
3. Download last month's invoice
Out of scope: <marketing site, admin console>

Without tasks, an evaluation drifts into visual opinion. If the user gives none, propose tasks from the product’s main routes (rg -n "path:|route\(|<Route" src) and confirm.

2. Walk the flows

Prefer the running app. In a Codex sandbox, starting a dev server may need approval, and reaching staging needs network access; ask before logging in with any credentials and use only test accounts the user provides or the repo seeds.

npx playwright codegen http://localhost:3000     # record a walk; produces steps you can replay
npx playwright screenshot --full-page http://localhost:3000/settings/billing billing.png

Capture every state you pass: empty, loading, error (disconnect network in devtools, submit invalid data), success, and long content. Many violations live only in those states. If only screenshots or a Figma file are available, evaluate them and mark interaction-dependent findings as “needs confirmation in build”.

Read the code where it explains behaviour you cannot trigger: validation rules, error copy, timeouts (rg -n "toast|Toast|alert\(|error\." src).

3. Log findings

One row per problem per location. Write what you saw, not what you felt.

| ID | Task | Screen / element | Observation | Heuristic | Sev | Fix |
|---|---|---|---|---|---|---|
| F07 | 2 | Invite modal, "Send" | After Send, modal closes with no confirmation; invite not visible in member list until refresh | H1 | 3 | Show "Invite sent to [email protected]" toast and add a "Pending" row immediately |

Rules:

  • One heuristic per finding (the primary one). If two apply, choose the one whose fix matches your recommendation.
  • A finding without evidence (screenshot, URL, reproducible steps) does not go in the report.
  • Fixes describe the change, not “improve clarity”. Suggest copy when the problem is copy.
  • Record strengths too (things to keep), so the fix list does not remove them.

4. Consolidate

  • Merge the same problem across screens into one finding with a list of locations.
  • Sort by severity, then by how many tasks are affected.
  • Group fixes that share a cause (“no global toast system” explains six H1 findings).
  • Flag the 3-5 findings worth validating with real users.

Gotchas

  • Heuristics catch expert-visible problems; they miss domain misunderstandings and motivation issues. State that limitation; never present findings as user data.
  • One evaluator finds a minority of problems. If the user can, have 2-3 people evaluate independently and merge. When you are the only evaluator, say so.
  • Do not let aesthetic preference masquerade as H8. Clutter is a finding only when it hides something the user needs.
  • Consistency (H4) includes platform conventions: a custom date picker that breaks keyboard entry is a violation even if it is internally consistent.
  • Accessibility overlaps but is not the same review. Note obvious barriers and recommend $wcag-accessibility-audit for conformance.

Verification

  • Every severity 3-4 finding has a screenshot and reproducible steps.
  • Re-walk each task using only the report’s fixes as a mental patch: would the task now complete without the friction? If not, a finding is missing.
  • Each fix is feasible within the product’s stack; check with the code when unsure.

Report template

# Heuristic evaluation: <product area>
Date: <date>  Evaluator(s): <n>  Build: <url / commit>  Viewports: <desktop 1440, mobile 390>
Method: expert inspection against Nielsen's 10 heuristics, severity 0-4. Not user testing.

## Summary
<3-5 sentences: overall state, top risks, recommended next step>
Findings: <n> total - <a> catastrophic, <b> major, <c> minor, <d> cosmetic

## Top issues
1. **[Sev 4, H5] Delete workspace has no confirmation** - Settings > Danger zone.
   Evidence: shots/f02.png. Fix: typed-name confirmation dialog; 30-day soft delete.

## All findings
| ID | Task | Location | Observation | Heuristic | Sev | Fix |

## Heuristic coverage
| Heuristic | Findings | Worst severity |

## Strengths to keep
- <...>

## Recommended for user testing
- <finding IDs and the question to test>

## Limits
<states not reachable, roles not tested, single evaluator>

Related: rewrite state copy with $ui-copy-states; map the flow you evaluated with $user-flows; a visual polish critique is $ui-design-review.

What the zip contains

Codex reads bundled files only when a step points to them. Every one is shown here, so you can review it before installing.

agents/openai.yamlgenerated from this page

Gives the Codex app a display name, a one-line description and a starter prompt for this skill.

interface:
  display_name: "Usability Heuristics"
  short_description: "Nielsen-based UX audits with evidence and fixes"
  default_prompt: "$usability-heuristics Do a heuristic evaluation of our signup and onboarding flow"
references/heuristics-checklist.md123 lines, 5.2 KB
# Heuristic probe checklist

Use while walking each screen. Each heuristic lists probes (what to try or look for) and
the violation patterns that turn up most often in web and mobile products. A probe that
fails becomes a finding only with evidence.

## H1 Visibility of system status

Probes:
- Click every primary button. Is there feedback within 100 ms (pressed state, spinner)?
- Throttle the network to "Slow 4G". Does anything show progress after 1 s? Is there
  a percentage or step count for operations over 10 s?
- After save/send/delete, is the result visible where the user is looking?
- Is the current location shown (active nav item, page title, breadcrumb, step x of y)?
- Are background jobs (imports, exports, uploads) visible after leaving the page?

Common violations: silent saves; spinners with no timeout; disabled button with no
reason; upload progress lost on navigation; "Saved" shown before the request succeeds.

## H2 Match between system and the real world

Probes:
- Read every label aloud to an imagined target user. Any internal jargon, table names,
  enum values (`PENDING_REVIEW`), or developer terms?
- Are dates, money and units in the user's locale and format?
- Does the order of fields and steps match how the user thinks about the task
  (shipping before payment, name before email)?
- Do icons mean what the user expects without a tooltip?

Common violations: error codes as messages; "Entity", "Tenant", "Resource" in UI copy;
ISO timestamps; ambiguous icons (a gear for three different things).

## H3 User control and freedom

Probes:
- Can every modal be closed with Esc, a close button, and (on mobile) back?
- Is there undo for delete, archive, send, move? Or at least a confirmation for
  irreversible actions?
- Does browser back go where the user expects, without losing form input?
- Can a multi-step flow be left and resumed?

Common violations: wizard that resets on back; no undo after bulk actions; modal traps;
auto-advance carousels with no pause.

## H4 Consistency and standards

Probes:
- Same action, same label everywhere? ("Remove" vs "Delete" vs "Archive" for one action)
- Primary button style and position consistent across dialogs?
- Links look like links; buttons look like buttons; platform controls behave natively
  (date fields accept typing, selects open with keyboard)?
- Terminology matches the rest of the product and the industry.

Common violations: OK/Cancel order flips between dialogs; custom controls that break
platform keyboard behaviour; two different icons for the same concept.

## H5 Error prevention

Probes:
- Try invalid input: wrong formats, too long, empty, duplicates. Is it constrained or
  validated before submit?
- Are destructive actions separated from frequent ones and confirmed with specifics
  ("Delete 14 files?")?
- Are sensible defaults set? Are impossible options disabled with a reason, or hidden?
- Double-submit: click Pay/Send twice quickly.

Common violations: free-text where a picker fits; delete next to edit with equal weight;
double charges or duplicate records from double-clicks; confirmation dialogs that only
say "Are you sure?".

## H6 Recognition rather than recall

Probes:
- Does any step require remembering information from a previous screen?
- Are recent items, previous choices and search history offered?
- Are options visible, or hidden behind unlabeled icons and gestures?
- Do form fields keep visible labels after typing (no placeholder-only labels)?

Common violations: codes the user must copy between screens; icon-only toolbars; filters
whose active state is not shown.

## H7 Flexibility and efficiency of use

Probes:
- Can frequent users do the main task faster: keyboard shortcuts, bulk select, saved
  filters, duplicates, templates?
- Does the system remember preferences (sort, view, last workspace)?
- Is autofill supported (`autocomplete` attributes)?

Common violations: no bulk actions on lists; settings that reset each visit; paste
blocked in fields.

## H8 Aesthetic and minimalist design

Probes:
- On each screen, what is the one thing the user came for? Is it the most prominent?
- Remove each element mentally: would anyone miss it?
- Are secondary details progressively disclosed instead of shown all at once?

Common violations: promotional banners above the task; equal visual weight for every
action; dense tables with rarely used columns shown by default.

## H9 Help users recognise, diagnose and recover from errors

Probes:
- Trigger each error you can. Does the message say what happened, why, and what to do?
- Is the error placed next to the cause and announced to screen readers?
- Is user input preserved after an error?
- Are server and network failures distinguished from validation errors, with retry?

Common violations: "Something went wrong"; errors only at the top of long forms; form
cleared after a failed submit; 404 pages with no path forward.

## H10 Help and documentation

Probes:
- For complex fields, is there inline help (helper text, examples) rather than a link
  to a manual?
- Is help searchable and does it match the current UI?
- Is there a way to contact support from the place the user gets stuck?

Common violations: help center screenshots from an old UI; tooltips as the only
explanation on touch devices; no example values for formatted inputs.

About this skill

Written and maintained by the Codex Skills editors to the same editorial standard as every skill here: a selective description, a real workflow, known pitfalls and a way to verify the work. First published , last updated . MIT licensed. Something wrong or out of date? Tell us.

esc
New

Introducing Codex Skills Pro

79 professional skills that take Codex through complete engagements, each with its own scripts, references and a report that verifies the result.

All-AccessOne-time payment, no subscription
$49
Get All-AccessOr browse individual skills from $2.99 →

Secure checkout by Creem