More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Accessibility Auditor (WCAG 2.2)

    2

    Find accessibility barriers and WCAG 2.2 AA failures in web and mobile UI code — with file:line, the exact criterion, and a fix

    $10

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    1 use5.0 (1 review)

    Accessibility Auditor (WCAG 2.2)

    Example session with this skill installed

    Audit my React storefront for accessibility before we launch in the EU — what would block users or fail WCAG?

    • Read your context and instructions
    • Compiled the accessibility auditor wcag

    Detected: Web — Next.js 14 (React, Tailwind). Legal scope: EU Accessibility Act / EN 301 549 + ADA. Target: WCAG 2.2 AA.

    Writing the full report to ACCESSIBILITY_AUDIT.md.

    Summary: 12 findings — 3 Critical, 4 High, 3 Medium, 2 Low. Statically: not conformant.

    Most impactful: your icon-only search and "add to cart" buttons have no accessible name, so screen-reader users hear only
    "button" and literally can't shop. Add aria-labels and hide the decorative icons. Same severity: the currency dropdown is a
    div-with-onClick that keyboard users can't operate — it blocks checkout.

    High: body text at #949494 on white is 2.9:1 (fails 4.5:1); a global outline: none removes focus indicators; checkout inputs
    use placeholders instead of real labels; zoom is disabled in the viewport meta.

    First moves: fix the three Criticals (search, currency, form labels), restore visible focus, bump body contrast. The full report
    has file:line, the WCAG criterion, and a fix for each, plus a "Verify manually" list for screen-reader checks.

    Static audit, not a full conformance evaluation — confirm the manual items with a screen reader before claiming EAA conformance.

    Writing the full report to ACCESSIBILITY_AUDIT.md

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Accessibility lawsuits and the EU Accessibility Act (in force since June 28, 2025) made a11y a legal requirement, not a nice-to-have. This skill audits your UI code for the barriers that exclude users with disabilities and fail WCAG 2.2 AA — before they reach users or regulators.

    What it checks

    Framework-aware checks for web (React, Vue, Angular, Svelte, plain HTML) and mobile (React Native, Flutter, native iOS/SwiftUI, native Android/Compose):
    • Names & labels — icon-only buttons with no accessible name, unlabeled form inputs, images missing alt/labels (the most common blocker)
    • Keyboard & focus — mouse-only custom widgets, keyboard traps, removed focus indicators (`outline: none`), bad tab order
    • Color & contrast — text below 4.5:1 (computed when colors are readable), meaning conveyed by color alone
    • Structure — heading order, landmarks, semantic HTML vs div soup
    • Forms — placeholder-as-label, errors shown only in color or not associated with fields
    • WCAG 2.2 additions — target size (24×24), focus not obscured, dragging alternatives, accessible authentication (paste-blocking on OTP, CAPTCHAs)
    • Mobile specifics — accessibilityLabel/contentDescription/Semantics, touch targets, dynamic type, VoiceOver/TalkBack state and announcements, reduced motion

    Legal scope, automatically

    Detects your target markets and cites the right regime — EU Accessibility Act / EN 301 549, ADA, Section 508, AODA — while keeping the technical target at WCAG 2.2 AA (the strict common denominator). It even distinguishes which criteria are required today under EU's WCAG 2.1 reference vs the newer 2.2 additions.

    How it works

    1. Detects platform, framework, and legal scope.
    2. Maps every UI surface with a11y obligations — images, controls, forms, structure, color, focus, motion, auth.
    3. Audits against WCAG 2.2 AA with framework-idiomatic patterns.
    4. Writes ACCESSIBILITY_AUDIT.md graded by user impact (Critical/High/Medium/Low) — each finding leads with who is blocked and from what, plus file:line, the exact WCAG criterion, and a concrete fix. Runtime-only checks go in a "Verify manually" section with steps.

    Why buy it

    • Severity by user impact — "screen-reader users can't checkout" beats an abstract rule number; you fix what actually matters first
    • Concrete, framework-correct fixes — real JSX/SwiftUI/Compose snippets, not "add a label"
    • Computes contrast — states the actual ratio (e.g. "#949494 on #fff = 2.9:1, fails") when colors are resolvable
    • Honest about static limits — routes screen-reader/keyboard/zoom checks to "Verify manually" instead of faking pass/fail
    • Complements axe/Lighthouse — catches the context they miss (is the alt text meaningful? is the focus order logical?)
    • Agent-agnostic — Claude Code, Cursor, Codex CLI, Copilot, Gemini CLI

    Who it's for

    • Teams shipping to the EU (EAA), US (ADA/508), or Canada (AODA)
    • Anyone who got a demand letter or is preparing a VPAT/ACR
    • Web and mobile devs who want a11y caught in code review, not in production

    Limitations

    Static code audit, not a full conformance evaluation. Some criteria need manual testing with assistive technology (it tells you which). Doesn't run axe/Lighthouse, doesn't produce a binding VPAT/ACR, doesn't redesign your UI.

    Static code audit, not a full WCAG conformance evaluation. Criteria that need a running app + assistive tech (reading order quality, screen-reader announcements, focus order through complex widgets, 200%/400% zoom reflow) are routed to a "Verify manually" section with steps. Contrast is computed only when both foreground and background colors are resolvable; theme variables that resolve at runtime are flagged for manual check. Does not run axe-core, Lighthouse, or eslint-plugin-jsx-a11y — it complements them with context-aware static review. Does not produce a legally binding VPAT/ACR or certify conformance. Does not modify UI code or redesign components; it reports findings with targeted fix snippets. EU note: EN 301 549 currently references WCAG 2.1 AA; the 6 WCAG 2.2 additions are labeled so you can prioritize required vs advisory.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    5.0
    1 review
    5
    1
    4
    0
    3
    0
    2
    0
    1
    0

    This skill has been used 1 time.

    Trust & safety

    Security scan

    Security scan passed 24 days ago

    Permissions

    Write Files
    Read Files

    File Scopes

    **/*.{tsx
    jsx
    ts
    js
    vue
    svelte
    astro}
    **/*.{html
    htm}
    **/*.{css
    scss
    sass
    less}
    **/*.{swift
    kt
    java
    dart}
    **/res/layout/**
    **/*.xib
    **/*.storyboard
    **/tailwind.config.{js
    ts}
    **/theme*.{js
    json}
    **/package.json
    **/pubspec.yaml
    ACCESSIBILITY_AUDIT.md

    Static analysis only. Reads UI source (components, templates, styles, native layouts) and theme/color tokens to detect accessibility barriers and compute contrast where colors are resolvable. Writes a single file (ACCESSIBILITY_AUDIT.md). No network, no shell, no browser, no environment reads. It does not run axe/Lighthouse or any browser; runtime-only checks are listed for manual verification.

    Listed6 months ago

    What's inside

    Frequently Asked Questions

    This skill audits code for web (React, Vue, Angular, Svelte) and mobile (React Native, Flutter, Swift/SwiftUI, Kotlin/Compose), providing specific file:line locations and framework-correct code snippets for fixes.

    It is built to be agent-agnostic and performs exceptionally well with Claude Code, Cursor, Copilot, and CLI-based tools like the Gemini or Codex CLI.

    The skill maps failures to specific legal regimes like the EU Accessibility Act (EAA), ADA, and Section 508, ensuring your codebase meets the strict WCAG 2.2 AA common denominator required for global compliance.

    While it identifies structural and logical errors many tools miss, it acknowledges the limits of static analysis by providing a 'Verify manually' section with step-by-step instructions for screen-reader and keyboard testing.

    You receive the full skill definition including auditing logic for WCAG 2.2 criteria, framework-specific remediation patterns, and the automated reporting structure for generating impact-graded ACCESSIBILITY_AUDIT.md files.

    The Auditor prioritizes issues by 'User Impact' (Critical to Low), explaining exactly who is blocked (e.g., screen-reader users) so your team can focus on fixing high-risk barriers first.

    New in Security