accessibility-review
Skill0 starsChanged 4 months agoMITView on GitHub
Audits a digital product against recognized accessibility standards — WCAG (the W3C Web Content Accessibility Guidelines) and IBM's accessibility requirements — and produces a prioritized findings report mapping each issue to the specific success criterion it fails, with severity and a concrete fix. Use this whenever the user wants an accessibility review, a11y audit, WCAG check, Section 508 / EN 301 549 conformance pass, or wants to know whether a screen, component, flow, PDF, or document is accessible; wants to fix contrast, keyboard, screen-reader, focus, alt-text, form-label, or ARIA problems; or asks which WCAG criterion something violates. Reach for it even when "accessibility" isn't named — any request to make a UI usable for people with disabilities, or to meet a legal accessibility requirement, qualifies.
19 other projects use a version of this.
Adopted by
Most recently taken up by
- Vujavujavuja/Stillmotion-onbrandtheir own version, first seen Nov 16, 2026
- samsam007b/claude-code-standards-kittheir own version, first seen Nov 16, 2026
- WilliamEbong/CourseForgetheir own version, first seen Nov 8, 2026
- nisarth/claude-skills-storetheir own version, first seen Nov 8, 2026
- toribryan/design-skillstheir own version, first seen Oct 25, 2026
- shayan-m81/layerwrighttheir own version, first seen Oct 13, 2026
Used with
Projects with it also use frontend-design.
Other files people use alongside this one.
Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
BlockSkillfrontend-design
Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.
Also in 4 projects that use this
Other versions19 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 19
- anthropics/knowledge-work-plugins★ 36ksame name
- markmead/hyperui★ 12ksame name
- ThibautBaissac/rails_ai_agents★ 665same name
- shayan-m81/layerwright★ 8same name
- Uwayxt/agent-skills★ 4same name
- francogalfre/skills★ 3same name
- ChloeVPin/open-agent-skills★ 2same name
- ethicalcapital/skills★ 2same name
- gvago/unofficial-qodo-review-skills★ 2same name
- loganware05/captains-compass-cursor★ 2same name
9 more not listed
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository6 other files it gives its agents.
- competitive-analysisSkill
- design-fundamentalsSkill
- heuristic-evaluationSkill
- inclusive-designSkill
- persona-builderSkill
- ux-usability-studySkill
The file
We split this skill into the rules it gives an agent
3 rules. 0 are common, 2 are distinctive, and 1 is very specific to this project.
0
Common
Most of the 16 edited versions we read keep these.
2
Distinctive
This author's own choices. Worth a look.
1
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 79
Text alternatives (1.1.1): every informative image/icon has meaningful alt text.
- Distinctive: line 104
Labels & instructions (3.3.2): every input has a programmatic, visible label.
- Very specific: line 178
Default to a Markdown report.
“Common” is measured: kept by at least 6 in 10 of the 16 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Accessibility Review
This skill audits a product for accessibility — how well people with disabilities (visual, motor, auditory, cognitive, situational) can perceive, operate, and understand it — and writes up what to fix, tied to the standard it fails. Accessibility isn't a subjective "nice to have": it's governed by published, testable standards, and much of it is a legal requirement (ADA, Section 508 in the US, EN 301 549 / the European Accessibility Act in the EU). Grounding findings in those standards is what makes the report credible and actionable.
Two honest framing points to carry into any review:
- Automated checks catch only part of it. Tools (axe, WAVE, Lighthouse) find maybe a third of issues — mostly contrast, missing alt, missing labels. The rest (meaningful focus order, sensible reading order, whether alt text is good, whether an interaction is truly operable by keyboard and screen reader) needs human judgment. Say so, and don't imply a clean automated scan means "accessible."
- You often can't fully verify from a description. Real conformance testing needs the running product, a keyboard, and a screen reader. When you only have a screenshot or a description, give your best assessment, be explicit about what you couldn't verify, and never claim conformance you didn't test.
The standards to reference
Reference these directly and by name — they're public norms, and citing them precisely is what gives the review authority.
- WCAG (Web Content Accessibility Guidelines) — the W3C standard, the backbone of nearly every accessibility law. Organized under four principles (the POUR model): content must be Perceivable, Operable, Understandable, Robust. Each principle contains testable success criteria, each at a conformance level: A (must), AA (the near-universal legal/industry target), and AAA (enhanced). Cite criteria by number and name, e.g. 1.4.3 Contrast (Minimum, AA), 2.1.1 Keyboard (A), 4.1.2 Name, Role, Value (A). Default target is WCAG 2.1 (or 2.2) Level AA unless the user states otherwise. Paraphrase the requirement in plain language — don't paste long verbatim spec text; point to the criterion so they can look it up.
- IBM Accessibility — IBM publishes an accessibility requirements checklist and practical developer/designer guidance built on top of WCAG. Reference it as a well-regarded, actionable interpretation of the same criteria, useful for concrete "how to fix" direction.
- Mention the relevant legal framework when the user's context implies one (Section 508, EN 301 549, ADA) — they mostly adopt WCAG AA by reference, so the technical work is the same.
How to run the review
1. Set scope and target
Pin down: what's being reviewed (screen, flow, component, whole product, a PDF or document), the conformance target (default WCAG 2.2 AA), and the context (web, native mobile, email, document — the criteria apply but the techniques differ). Ask what you're working from — live URL, prototype, screenshots, code — since that determines how much you can actually verify.
2. Evaluate across the POUR principles
Walk the interface against each principle. The high-frequency checks, grouped:
Perceivable
- Text alternatives (1.1.1): every informative image/icon has meaningful alt text; decorative images are marked so screen readers skip them.
- Color contrast (1.4.3 / 1.4.11): text meets ≥4.5:1 (≥3:1 for large text);
UI components and meaningful graphics meet ≥3:1. Measure it, don't eyeball —
run the bundled
scripts/contrast.py <fg> <bg>(accepts hex,rgb(), or basic names) to get the exact ratio and per-threshold pass/fail, and cite that number in the finding. - Color not the only cue (1.4.1): information (errors, status, links) isn't conveyed by color alone — pair with text, icon, or underline.
- Captions & transcripts (1.2.x): video has captions, audio has transcripts.
- Reflow & resize (1.4.4 / 1.4.10): content works zoomed to 200% and reflows to a narrow viewport without loss.
- Meaningful sequence (1.3.2): the DOM/reading order matches the visual order.
Operable
- Keyboard (2.1.1 / 2.1.2): everything works with keyboard alone; no traps.
- Focus visible & order (2.4.7 / 2.4.3): a clear focus indicator, and focus moves in a logical order.
- Target size (2.5.8): interactive targets are large enough (≥24×24 CSS px).
- Timing & motion (2.2.1 / 2.3.1): adjustable time limits; nothing flashes more than 3×/second; respect reduced-motion.
- Skip/bypass & headings (2.4.1 / 2.4.6): a way past repeated blocks; descriptive headings and labels.
Understandable
- Labels & instructions (3.3.2): every input has a programmatic, visible label; instructions aren't placeholder-only.
- Errors (3.3.1 / 3.3.3): errors are identified in text, tied to the field, and offer a correction.
- Consistency & predictability (3.2.x): navigation and components behave consistently; nothing changes context unexpectedly on focus/input.
- Language & clarity (3.1.1): page language is set; plain language for cognitive accessibility.
Robust
- Name, Role, Value (4.1.2): custom components expose correct name, role, and state to assistive tech — usually via native HTML first, ARIA only where needed and correct. Prefer semantic HTML over ARIA patches.
- Status messages (4.1.3): dynamic updates (toasts, validation, live results) are announced to screen readers.
Beyond the checklist, test the way disabled users actually operate where you can: tab through with the keyboard only, run a screen reader (VoiceOver, NVDA, TalkBack), zoom to 200%, and check reduced-motion / dark-mode. Cognitive accessibility (clear language, low memory load, forgiving flows) matters too and is easy to overlook.
3. Log each issue against a criterion
For each problem, capture:
- Location — screen/component/element.
- The barrier — who it blocks and how (e.g. "keyboard users can't reach the Close button; the modal traps focus").
- WCAG criterion (and level) it fails — cite number + name.
- Severity — see below.
- How to fix — concrete, ideally the accessible-HTML/ARIA technique or design change.
4. Rate severity
Combine user impact (does it block a task for someone, or just add friction?) with how many users and how central the path is. A pragmatic scale:
- Blocker — makes a task impossible for a group (e.g. unlabeled checkout button unusable by screen readers; keyboard trap). Must fix.
- Serious — major difficulty or exclusion on a common path (e.g. failing contrast on body text, no visible focus).
- Moderate — noticeable barrier with a workaround.
- Minor — small friction or best-practice gap.
Note conformance level too: an A failure is more fundamental than an AA one. Where a legal target applies, flag which failures put conformance at risk.
5. Write the report
# Accessibility Review: [product / screen] — [WCAG 2.2 AA]
## Overview
What was reviewed, target standard, what you tested with, what you could/couldn't verify
## Summary
Issue counts by severity, top blockers, overall conformance read (honest)
## Findings (most to least severe)
For each: location, barrier + who it affects, WCAG criterion (number + name + level),
severity, how to fix
## Prioritized fixes
Blockers first; group quick wins
## What still needs manual/AT testing
Explicitly list what a keyboard + screen-reader pass on the live product must confirmLead with blockers, cite the criterion on every finding, and make fixes concrete enough to act on. Frame accessibility as designing for the full range of human ability — it overwhelmingly improves the experience for everyone (the curb-cut effect), not just users with disabilities.
Producing the deliverable
Default to a Markdown report; offer a .xlsx issue log (one row per issue:
location / barrier / WCAG criterion / level / severity / fix / status) when the
user wants to track remediation. Use [placeholders] for anything you couldn't
verify, and clearly separate confirmed findings from "likely — needs testing."
Bundled tools & automated checks
scripts/contrast.py <fg> <bg>— exact WCAG contrast ratio and per-threshold pass/fail (used in the contrast check above). Accepts hex,rgb(), or basic names.scripts/readability.py "<text>"— Flesch Reading Ease / grade level, for plain-language and cognitive-accessibility checks (relevant to WCAG 3.1.5 and cognitive load generally).- For the automated ~30% — missing
alt, unlabeled inputs, name/role/value, missinglang, and similar mechanical failures — point the user to the free, well-maintained scanners (axe / axe DevTools, Google Lighthouse, Pa11y, WAVE) rather than hand-checking them. Don't reinvent those. This skill focuses on the ~70% they can't catch: meaningful focus and reading order, whether alt text is actually good, sensible error recovery, and real keyboard/screen- reader operability.
Pairs well with
- heuristic-evaluation — general usability audit; run both to cover usability and accessibility.
- design-fundamentals — contrast, hierarchy, and type choices that prevent many a11y issues.
- inclusive-design — accessibility is inclusion for disability; inclusive-design widens the lens further.
Standards & sources
WCAG is an open W3C standard and IBM's accessibility guidance is publicly published; referencing them by name, citing criteria by number, and paraphrasing their requirements is encouraged and builds credibility. The one caution is about their text: don't paste long verbatim passages of the copyrighted specification or guideline prose — paraphrase the requirement and point to the source. Auditing the user's own product and using their own screens/code is exactly the intended use.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

