AI Skill Report Card

Auditing UI Quality

A-90·Nov 19, 2026·Source: Web
13 / 15

Run this checklist against the target interface/codebase and compute the weighted score:

Progress:
- [ ] 1. UI/UX Design Quality        (weight: 20)
- [ ] 2. Device/Screen Compatibility (weight: 15)
- [ ] 3. Performance & Rendering     (weight: 15)
- [ ] 4. Code & Engineering Quality  (weight: 15)
- [ ] 5. Interactions & Functionality(weight: 15)
- [ ] 6. Accessibility (WCAG 2.2 AA) (weight: 10)
- [ ] 7. Testing & Stability         (weight: 10)

Never declare a project "done" from the numeric score alone — see Mandatory Rule below.

Recommendation▾
Add one or two more worked examples covering a passing/high-score case to show contrast with the two failure-mode examples given
15 / 15

Step 1 — Gather Evidence (not opinions)

For every category, collect concrete, reproducible evidence before scoring:

  • Screenshots/recordings at breakpoints (mobile/tablet/desktop/TV)
  • Build logs (must show 0 errors)
  • Browser console output during a full user-flow run (must show 0 unhandled errors)
  • TypeScript compiler output (if applicable, 0 errors)
  • Lighthouse / performance trace (load time, FPS, memory)
  • Accessibility audit output (axe-core, WAVE, or equivalent)
  • Test run results (unit, integration, E2E) with pass/fail counts

If evidence cannot be produced for a category, that category scores 0, not an estimate.

Step 2 — Score Each Category (0 to max weight)

1. UI/UX Design Quality (20 pts)

  • Color/typography/spacing/sizing 100% consistent with design system → else deduct proportionally
  • Clear visual hierarchy, discoverable primary actions
  • No overlapping/clipped/unusable elements → any instance = automatic cap at 10/20
  • All interactive elements have visible hover/active/disabled/focus states

2. Device/Screen Compatibility (15 pts)

  • Test at minimum: 360px, 768px, 1024px, 1440px, and TV/10-foot UI if applicable
  • Zero unintended horizontal scroll, zero off-screen elements
  • Usable in portrait and landscape where applicable
  • Any horizontal scroll bug or off-screen element = automatic cap at 7/15

3. Performance & Rendering (15 pts)

  • Live preview updates <1s after typical changes (when environment allows)
  • Page load ≤2.5s under defined test conditions
  • 60fps for animations on capable devices
  • No unnecessary re-renders; memory/CPU monitored, no leaks over a sustained session
  • Missing performance measurement entirely = cap at 7/15

4. Code & Engineering Quality (15 pts)

  • Build errors = 0 → otherwise this category = 0 (hard fail, not partial)
  • TypeScript errors = 0 (if TS used) → otherwise this category = 0
  • Linting/formatting rules followed
  • No unjustified component duplication; reusable, maintainable structure
  • Project structure and user-specified stack preserved

5. Interactions & Functionality (15 pts)

  • Every button/link/menu/form actually performs its function (click through all of them — no "ghost" controls)
  • 100% of core user flows tested and passing
  • Loading / success / error / empty states present for every async operation
  • Input validation and error handling verified, not assumed

6. Accessibility — WCAG 2.2 AA (10 pts)

  • Full keyboard navigation (tab order logical, no traps)
  • Color contrast meets AA ratios
  • All interactive elements have accessible names (screen reader tested)
  • Visible focus indicators
  • Information never conveyed by color alone
  • Any keyboard-trap or missing-label found = cap at 5/10

7. Testing & Stability (10 pts)

  • Unit + integration + UI tests exist and pass
  • Responsive design tests executed
  • Normal and edge/exception cases covered
  • No fix is marked "successful" without a passing test proving it
  • Retest performed after every impactful change

Step 3 — Compute Total and Classify

ScoreClassification
95–100Exceptional quality
90–94Production-ready
80–89Good, improvements required
70–79Needs remediation
<70Not ready

Step 4 — Apply the Completion Gate

A project is only "ready" when all of the following hold simultaneously (score is necessary but not sufficient):

  • Overall score ≥ 90/100
  • All core functional tests pass
  • Zero critical or high-severity bugs open
  • Target-device compatibility tests pass
  • Accessibility tests pass
  • Build and run succeed cleanly
  • Live preview matches actual implementation pixel-for-pixel/behaviorally

Mandatory Rule

Never declare success based on the numeric score alone. The score is a summary signal, not proof. Success must be backed by reproducible test evidence (logs, screenshots, test reports) for every category claimed as passing. If asked "is this ready?", answer with the score and list the specific evidence verified, or state explicitly what evidence is missing.

Recommendation▾
Include a concrete sample output template (e.g., a filled-in score report) so the reporting format is fully unambiguous
16 / 20

Example 1: Input: A dashboard UI claims "100% complete," build passes, no automated tests exist. Output: Score capped — Testing & Stability = 0/10 (no evidence), overall capped below 90 regardless of other categories. Verdict: "Needs remediation — cannot certify readiness without test evidence." List exact missing tests required.

Example 2: Input: E-commerce checkout flow, all buttons wired, responsive at 3 breakpoints, console has 2 unhandled promise rejections during checkout. Output: Code Quality capped (console errors present during test = fail that sub-criterion), Interactions category flagged — checkout flow not fully passing. Overall score reported with breakdown per category, verdict: "70–79, needs remediation" with the two specific console errors quoted and reproduction steps.

Recommendation▾
Clarify how partial evidence (e.g., some but not all breakpoints tested) should be scored within a category rather than only all-or-nothing gates
  • Always show the per-category breakdown, not just the total — stakeholders need to know why.
  • Treat "0 build/console/TypeScript errors" as hard gates, not averaged-in deductions.
  • Re-run the full checklist after any change that touches layout, state, or data flow — partial re-checks hide regressions.
  • Prefer automated evidence (Lighthouse, axe, test runners) over manual judgment wherever a tool exists.
  • When design system is undefined, ask for it or flag "cannot verify 100% consistency" rather than guessing.
  • Declaring "production-ready" because the score formula totals ≥90 while a critical bug is still open — forbidden by the Mandatory Rule.
  • Scoring Accessibility from visual inspection alone without keyboard/screen-reader testing.
  • Counting a feature as "working" because the button exists, without actually triggering its handler.
  • Skipping retesting after a "small" CSS fix that can silently break other breakpoints.
  • Mixing up "preview looks fine" with "matches real build output" — always verify against the actual running implementation.
0
Grade A-AI Skill Framework
Scorecard
Criteria Breakdown
Quick Start
13/15
Workflow
15/15
Examples
16/20
Completeness
19/20
Format
15/15
Conciseness
14/15