Best AI Agent Skills for Accessibility Testing in 2026
A. Frans
Published July 19, 2026
Table of Contents
Most accessibility bugs are boring and mechanical: an icon button with no label, a form input with no associated <label>, a modal that traps focus in the wrong place, contrast that fails at 3.2:1 when it needed 4.5. None of these are hard to fix. They're hard to find, because finding them means clicking through every state of every page with a screen reader and a color picker. That's the work nobody has time for, which is why it doesn't happen until a lawsuit or an audit forces it.
An AI agent driving a real browser can do the tedious part. It can load a page, run an automated accessibility scan, tab through the interactive elements in order, and report which controls are unreachable or unlabeled. It won't catch everything (more on that below), but it clears out the mechanical 60% so a human can spend their time on the judgment calls. Here are the agent skills that make that possible.
Quick comparison
| Skill | What it does | Type | Best for | Trust |
|---|---|---|---|---|
| webapp-testing | Playwright-driven app testing | Skill | Automated a11y test flows | Official |
| Playwright MCP | Browser control for agents | MCP server | Live page inspection | Official |
| Playwright | Test framework + axe integration | Skill | Writing a11y test suites | Official |
| browser-use | Agent-driven browsing | Skill | Exploratory keyboard testing | Verified |
| Superpowers | Dev skill bundle | Skill | Verification discipline | Verified |
webapp-testing: the official starting point
webapp-testing is Anthropic's own skill for automated web app testing with Playwright, which makes it the natural base for accessibility work. It gives the agent a structured way to load a page, interact with it, and assert on the result. For a11y that means you can ask it to run an axe-core scan on a route and return every violation with its severity and the element that caused it. Axe is the same engine behind most commercial accessibility checkers, so the results are credible, not made up.
Because it's an official Anthropic skill, install is straightforward from the skills repo. The pattern that works: point the agent at a list of routes, have it inject axe on each, and collect the JSON report. You get a per-page list of missing labels, contrast failures, and ARIA misuse in one pass instead of one page at a time. This is the skill I'd install first.
Playwright MCP: inspect the page as it really renders
Playwright MCP is Microsoft's official browser-automation server for agents, and its strength for accessibility is that it exposes the accessibility tree, not just the visual page. The accessibility tree is what a screen reader actually consumes: the roles, names, and states of every element. When a button "works" visually but shows up as an unnamed generic in the tree, a screen reader user hits a dead end. Playwright MCP lets the agent read that tree and flag the gaps.
Install is genuinely one line, which is rare in this list: claude mcp add playwright -- npx @playwright/mcp@latest. From there the agent can navigate, snapshot the accessibility tree for any route, and tell you which interactive elements have no accessible name. At 35,000 stars and maintained by Microsoft, it's the most reliable live-inspection option. Pair it with webapp-testing: one drives structured test runs, the other does exploratory inspection.
Playwright: bake a11y into the test suite
The Playwright framework itself (93,000 stars, maintained by Microsoft) is worth having as a skill when you want accessibility checks to live in CI, not just in an ad-hoc agent session. With the @axe-core/playwright package, a few lines assert that a page has zero critical violations, and that test fails the build the moment someone ships an unlabeled button. The agent's job here shifts from finding bugs to writing the tests that prevent regressions.
Ask the agent to generate accessibility tests for your key user flows and it can scaffold a suite that scans each page and each important state, such as a modal open, a form in its error state, a menu expanded. States matter: an accessibility scan of a page with the modal closed misses every bug inside the modal. See the repo for setup, and our QA testing skills guide for how this fits a broader test strategy.
browser-use: keyboard-only, the way a real user hits it
Automated scans catch what's machine-detectable. They don't catch "you can see the menu but you can't reach it with the Tab key." browser-use drives a browser the way a person would, which makes it the tool for exploratory keyboard testing. Have the agent navigate a checkout flow using only keyboard events and report where focus gets lost, where it jumps somewhere unexpected, or where a control simply can't be reached without a mouse.
At 105,000 stars it's one of the most popular agent-browsing projects, and this exploratory angle complements the structured scans above. Focus-order bugs are among the most common real-world accessibility failures and among the hardest to catch with a static scan. Install from the repo. Use it for the "can a keyboard user actually complete this task" question that axe can't answer.
Superpowers: the discipline layer
Superpowers is a 257,000-star bundle of core development skills, and the reason it belongs here is its verification-before-completion habit. Accessibility work fails quietly when an agent says "fixed the contrast" without re-scanning to confirm the new values actually pass. The verification skill pushes the agent to check its work against the requirement before declaring done, which for a11y means re-running the scan after each fix. Install from the repo. It's less a scanner than a guardrail that keeps the other tools honest.
A concrete workflow
Here's a setup that produces real results on day one. Install webapp-testing and give the agent a list of your top ten routes. Ask it to load each, inject axe-core, and return a combined report grouped by violation type. Within a few minutes you have a ranked backlog: 14 missing form labels across four pages, 6 contrast failures in the footer, 3 buttons with no accessible name in the nav. That backlog would have taken a person a full afternoon of manual clicking to assemble.
Then the second pass, which is where most tools stop but shouldn't. Add Playwright MCP and have the agent open your checkout flow, snapshot the accessibility tree at each step, and tab through it using keyboard events only. This catches the bugs axe can't: the "Add to cart" button that's reachable by mouse but skipped in the tab order, the error message that appears visually but never announces to a screen reader. Fix a batch, then have the agent re-scan to confirm the numbers actually dropped. That re-scan discipline is the difference between "I fixed it" and "I checked that I fixed it."
How to choose
For most teams the pairing is webapp-testing plus Playwright MCP: structured axe scans for the mechanical violations, live accessibility-tree inspection for the subtle ones. Add browser-use when keyboard navigation is a real concern, which it should be for anything with forms or checkout. If you want the checks to stick, use the Playwright framework to move them into CI so regressions fail the build.
One honest limitation worth stating plainly: automated tools catch roughly a third to a half of WCAG issues. They're excellent at missing labels, contrast ratios, and ARIA misuse. They cannot judge whether your alt text is meaningful, whether your heading structure tells a coherent story, or whether a color-coded chart makes sense to someone who can't see color. An agent clears the mechanical backlog fast, which frees a human to spend their limited time on the judgment calls that actually need a human. Treat these skills as a force multiplier, not a compliance stamp.
FAQ
Can an AI agent make my site fully WCAG compliant? No, and be wary of anything that claims it can. Automated scanning catches roughly 30 to 50% of WCAG issues, the mechanical ones. Meaningful alt text, logical heading order, and non-color-dependent information still need human judgment. These skills make the human's job smaller, not unnecessary.
Which skill should I install first? webapp-testing for structured axe scans, or Playwright MCP if you want to poke at pages interactively. Both are official and reliable. Playwright MCP has the simplest install of the group.
How is this different from a browser extension like axe DevTools? The extension scans one page while you have it open. An agent scans every route and every state in a batch, writes up the findings, and can turn them into CI tests so the bugs don't come back. Same underlying engine, far less manual clicking.
Does it test keyboard navigation and screen reader behavior? Keyboard navigation, yes, via browser-use or Playwright's keyboard events, and the accessibility tree via Playwright MCP approximates what a screen reader sees. Actual screen reader output still deserves a manual pass with NVDA or VoiceOver for anything critical.
Can it fix the issues, not just find them? It can propose fixes and often apply them, then re-scan to confirm. The Superpowers verification habit matters here so "fixed" means re-checked, not assumed. Review the diffs before merging.
Share this article
⚙Related Tools
📄Related Articles
Get More AI Tool Guides
New comparisons and guides every week. Join thousands of professionals staying ahead of the AI curve.