# accessibility

Adopt this skill: https://proskills.md/skills/other/evanca-flutter-ai-rules-skills-accessibility

Page: https://proskills.md/skills/other/evanca-flutter-ai-rules-skills-accessibility
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/accessibility/SKILL.md
size: 8073
upstream: https://github.com/evanca/flutter-ai-rules/blob/main/skills/accessibility/SKILL.md

```text
---
name: accessibility
description: "Use when working on accessibility, a11y, WCAG, ARIA, screen readers, keyboard nav, focus order, contrast, alt text, captions, reduced motion, or target sizes; not language/culture/device (see inclusive-design)."
license: MIT
---

# Accessibility

Accessibility answers one question:

> **Can someone use this with assistive tools, a different input method, or a different ability?**

It is specifically about people with disabilities being able to **perceive, understand, navigate, and interact** with a product on equal terms — whether they use a screen reader, only a keyboard, a switch, voice control, magnification, or captions. This is the *ability* half of designing for everyone. The *context* half — language, culture, device, affordability, confidence — belongs to the sibling **inclusive-design** skill. They overlap but have different focuses; keep them distinct so neither gets diluted.

## When to use

Use this skill when the task involves any of: WCAG conformance, ARIA, semantic markup, screen-reader support, keyboard/focus management, color contrast, text alternatives (alt text, captions, transcripts), accessible forms and error messages, target sizes, timing/timeouts, motion sensitivity, or cognitive accessibility. Also use it whenever someone asks to "make this accessible," run an a11y audit, or check whether a disabled user can complete a task.

**When *not* to use it:** if the real concern is who gets *left out* by context — non-English speakers, people on cheap phones or slow networks, people who can't afford data, first-time or anxious users, or global name/address formats — that is inclusion, not accessibility. Switch to the **inclusive-design** skill.

## The mental model: POUR

WCAG organizes all of accessibility under four principles. Use them as your audit lens — every issue you find maps to one of them.

- **Perceivable** — users can sense the content through *some* channel. Don't rely on one sense alone. (Text alternatives for images, captions/transcripts for audio and video, sufficient color contrast, not using color alone to convey meaning, content that reflows and survives zoom.)
- **Operable** — users can drive the interface with *whatever input they have*. (Everything reachable and usable by keyboard, visible focus, no keyboard traps, adequate target sizes, generous or adjustable time limits, nothing that flashes in a seizure-inducing way.)
- **Understandable** — users can predict and comprehend behavior. (Clear labels, instructions, and error messages; consistent navigation; predictable interactions; readable language.)
- **Robust** — assistive tech can actually parse it. (Valid semantic structure; correct name/role/value on every control; native semantics first, ARIA only to fill gaps.)

A useful test for any element: *if I could not see it, hear it, use a mouse, or read quickly — could I still complete this task?* If the answer is no under any of those, you've found the principle that's failing.

## Who and what you are designing for

Design for the assistive tools and input methods people actually use, not an abstract "disabled user":

- **Screen readers** (VoiceOver, TalkBack, NVDA, JAWS) — need correct semantics, reading order, labels, and announcements of dynamic changes.
- **Keyboard-only and switch users** — need a logical focus order, visible focus, and no mouse-only interactions.
- **Voice control** — needs visible, speakable labels that match the accessible name.
- **Screen magnification and zoom** — needs layouts that reflow without horizontal scrolling or clipping at 200%+.
- **Captions / transcripts users** — Deaf and hard-of-hearing users, *and* anyone in a loud or silent environment.
- **People with cognitive and learning disabilities** — need clear language, low memory load, and forgiving flows (see below).

Note the recurring pattern: most of these help far more people than the group they target — the same insight that drives inclusive design.

## Fast audit checklist

Walk these in order; each line is a concrete thing to check or fix.

1. **Keyboard** — Tab through the whole flow. Is every control reachable and operable? Is focus visible? Is the order logical? Can you get trapped?
2. **Screen reader** — Does every control announce a meaningful name and role? Are images given text alternatives (or marked decorative)? Are dynamic updates (errors, loading, toasts) announced?
3. **Contrast & color** — Does text meet contrast minimums (4.5:1 body, 3:1 large)? Is any meaning carried by color alone (e.g., red = error with no icon/text)?
4. **Structure** — Are headings, lists, landmarks/regions, and labels semantic rather than visual-only? Does reading order match visual order?
5. **Forms & errors** — Is every field labeled (not placeholder-only)? Are errors identified in text, tied to their field, and explained with how to fix?
6. **Targets & timing** — Are tap targets large enough and spaced? Are time limits absent, generous, or adjustable? Is autosave used to prevent data loss?
7. **Media & motion** — Captions/transcripts for audio/video? Does the UI honor reduced-motion preferences? Nothing flashing more than ~3×/second?
8. **Zoom/reflow** — At 200% zoom (or large system font), does content reflow without clipping or horizontal scroll?

## Beyond conformance: cognitive accessibility

WCAG alone does not cover everything people with cognitive and learning disabilities (dyslexia, ADHD, autism, dementia, aphasia, memory or attention differences) need. The W3C COGA guidance is **supplemental, not required for WCAG conformance**, and it is where the highest-leverage improvements for the largest hidden population usually live: clear language, consistent design, single-step instructions, not relying on memory, forgiving error recovery, and minimizing distraction.

Read **[references/cognitive-accessibility.md](references/cognitive-accessibility.md)** for COGA's eight objectives and their concrete design patterns when the task touches readability, complex flows, forms, logins, or "this is confusing/overwhelming."

## Motion, sensory, and age-related needs

Animation and motion can cause real harm (nausea, dizziness, loss of focus) for people with vestibular disorders, and seizures for people with photosensitivity. Honor the user's `prefers-reduced-motion` setting — reduce or replace motion rather than removing all feedback.

Older users are a large group whose age-related changes in vision, dexterity, hearing, and memory overlap directly with disability needs — designing well here helps everyone age into your product. (Treat *age as a context/identity dimension* — first-time confidence, life stage — in the inclusive-design skill; treat *age-related ability change* here.)

Read **[references/motion-and-sensory.md](references/motion-and-sensory.md)** for `prefers-reduced-motion` patterns (with code), photosensitivity limits, and the older-user ability overlap.

## How to verify

Automated checkers (axe, Lighthouse, Accessibility Scanner, etc.) catch maybe a third of issues — necessary but never sufficient. Always add manual checks: navigate the real flow with the keyboard only, then again with a screen reader, then with the OS reduced-motion and large-text settings on. The bug a tool can't catch — a focus order that makes no sense, a label that lies — is usually the one that actually blocks someone.

## References

Load these only when the task calls for the depth:

- [references/cognitive-accessibility.md](references/cognitive-accessibility.md) — W3C COGA: the 8 objectives and their design patterns (beyond WCAG).
- [references/motion-and-sensory.md](references/motion-and-sensory.md) — reduced motion (with CSS example), photosensitivity, older-user ability overlap.

Primary sources:

- [Accessibility, Usability, and Inclusion — W3C WAI](https://www.w3.org/WAI/fundamentals/accessibility-usability-inclusion/)
- [Making Content Usable for People with Cognitive and Learning Disabilities (C
```

## File: README.md
upstream: https://github.com/evanca/flutter-ai-rules/blob/main/README.md

````text
# Flutter AI Skills for Claude Code, Codex, Cursor, Antigravity, and Other AI Coding Agents

<img src="media/flutter_ai_skills.jpg" width="600" alt="An agent prompt reading &quot;Add Google sign-in to the profile screen&quot; on the left; on the right, the firebase-auth and flutter-app-architecture skills are auto-selected from a list of dozens">

**36 Flutter and Dart skills your coding agent loads by itself, sourced only from official documentation.**

A skill is a folder with a `SKILL.md` file. Your agent reads the description, decides a task matches, and pulls in the guidance — you don't paste anything into a rules file or remember to `@`-mention a doc. Install once, and Firebase Auth guidance shows up when you touch auth, Riverpod guidance when you touch providers.

A comprehensive, (almost) non-opinionated collection: everything here is derived from official Flutter, Dart, Firebase, and package documentation. No personal preferences, no invented conventions.

## ⚡ Quick start

```sh
npx skills add evanca/flutter-ai-rules
```

That's it. The [Skills CLI](https://www.npmjs.com/package/skills) discovers the packages under [`skills/`](./skills) and installs them for supported agents. It needs **Node 22.20 or newer** — on older versions it exits with `SyntaxError: ... does not provide an export named 'styleText'` before it does anything. Every other install route below works on any Node version, or none at all.

Browse before installing, or take just one:

```sh
npx skills add evanca/flutter-ai-rules --list
npx skills add evanca/flutter-ai-rules --skill flutter-best-practices
```

### Install as a plugin

This repo is also a plugin marketplace, so agents that support plugins can install the whole set and keep it updated in place. The manifests live at `.claude-plugin/`, `.codex-plugin/`, `.cursor-plugin/`, `.agents/plugins/`, and `plugin.json` — all pointing at the same [`skills/`](./skills) directory.

**Claude Code** — [plugin marketplaces](https://code.claude.com/docs/en/plugin-marketplaces):

```sh
/plugin marketplace add evanca/flutter-ai-rules
/plugin install flutter-ai-skills@flutter-ai-rules
```

Skills then load as `flutter-ai-skills:bloc`, `flutter-ai-skills:riverpod`, and so on.

**Codex** — [plugins](https://developers.openai.com/codex/plugins/build):

```sh
codex plugin marketplace add evanca/flutter-ai-rules
codex plugin add flutter-ai-skills@flutter-ai-rules
```

**Cursor** — [plugins](https://cursor.com/docs/plugins): in Cursor, run `/add-plugin`, or add the repo as a team marketplace under **Dashboard → Settings → Plugins → Import from Repo**:

```
https://github.com/evanca/flutter-ai-rules
```

**Antigravity** — [plugins](https://antigravity.google/docs/plugins):

```sh
git clone --depth 1 https://github.com/evanca/flutter-ai-rules.git
agy plugin install ./flutter-ai-rules
```

**Windsurf / Devin** has no plugin manifest, but Cascade already scans `.agents/skills/` and `~/.agents/skills/`, so the manual copy below is the install path. **GitHub Copilot** doesn't read `SKILL.md` at all — see [Rules and combined sets](#️-rules-and-combined-sets-legacy) for what to use instead.

Prefer to do it by hand? Copy or symlink any skill folder into your agent's skills directory — `.claude/skills/`, `.cursor/skills/`, `.codex/skills/`, `.agents/skills/` (Antigravity, Codex, Windsurf), `.windsurf/skills/`. Or vendor the whole set into your project:

```sh
git clone --depth 1 https://github.com/evanca/flutter-ai-rules.git temp_repo && mkdir -p .skills && cp -r temp_repo/skills/* .skills && rm -rf temp_repo
```

With a `.skills/` folder you can also reference a skill explicitly when you want it: *"Read `@.skills/bloc/SKILL.md` and create test coverage for the new methods."*

## 🧠 What's in the box

### Flutter and Dart foundations

| Skill | Loads when you're… |
|---|---|
| [`flutter-best-practices`](./skills/flutter-best-practices) | Writing, reviewing, or planning Flutter code |
| [`effective-dart`](./skills/effective-dart) | Writing Dart, naming things, adding doc comments |
| [`dart-3-updates`](./skills/dart-3-updates) | Using records, patterns, sealed classes, switch expressions |
| [`flutter-app-architecture`](./skills/flutter-app-architecture) | Scaffolding a project or refactoring into layers |
| [`architecture-feature-first`](./skills/architecture-feature-first) | Designing folder structure for a new feature |
| [`flutter-errors`](./skills/flutter-errors) | Hitting RenderFlex overflows, unbounded constraints, layout errors |
| [`flutter-use-column-row-first`](./skills/flutter-use-column-row-first) | Building responsive layouts with Row, Column, Expanded, Flexible |
| [`flutter-pre-caching`](./skills/flutter-pre-caching) | Preloading fonts, images, animations, or config |

### State management

| Skill | Loads when you're… |
|---|---|
| [`bloc`](./skills/bloc) | Creating a Cubit or Bloc, modeling state, wiring providers |
| [`riverpod`](./skills/riverpod) | Setting up providers, combining requests, managing disposal |
| [`provider`](./skills/provider) | Consuming state, optimizing rebuilds, using ProxyProvider |
| [`flutter-change-notifier`](./skills/flutter-change-notifier) | Setting up ChangeNotifier models and consuming them |

### Testing and review

| Skill | Loads when you're… |
|---|---|
| [`testing`](./skills/testing) | Writing unit, widget, or golden tests; fixing flaky tests |
| [`mockito`](./skills/mockito) | Generating mocks, stubbing, verifying interactions |
| [`mocktail`](./skills/mocktail) | Mocking without codegen, registering fallback values |
| [`patrol-e2e-testing`](./skills/patrol-e2e-testing) | Writing E2E tests that touch native permissions or dialogs |
| [`code-review`](./skills/code-review) | Reviewing a PR, branch, or diff |

### Firebase

| Skill | Loads when you're… |
|---|---|
| [`flutterfire-configure`](./skills/flutterfire-configure) | Adding Firebase to a project, running `flutterfire configure` |
| [`firebase-auth`](./skills/firebase-auth) | Setting up auth, managing auth state, social sign-in |
| [`firebase-cloud-firestore`](./skills/firebase-cloud-firestore) | Designing schemas, CRUD, listeners, pagination |
| [`firebase-database`](./skills/firebase-database) | Syncing real-time data, structuring JSON trees |
| [`firebase-storage`](./skills/firebase-storage) | Uploading and downloading files, managing metadata |
| [`firebase-analytics`](./skills/firebase-analytics) | Logging events, setting user properties |
| [`firebase-crashlytics`](./skills/firebase-crashlytics) | Capturing fatal and non-fatal errors |
| [`firebase-messaging`](./skills/firebase-messaging) | Setting up FCM, handling background messages |
| [`firebase-in-app-messaging`](./skills/firebase-in-app-messaging) | Running in-app campaigns |
| [`firebase-remote-config`](./skills/firebase-remote-config) | Implementing feature flags or A/B tests |
| [`firebase-app-check`](./skills/firebase-app-check) | Configuring attestation and debug tokens |
| [`firebase-cloud-functions`](./skills/firebase-cloud-functions) | Calling callable functions, handling errors |
| [`firebase-ai`](./skills/firebase-ai) | Generating text or chat with Gemini via `firebase_ai` |
| [`generate-images-with-firebase-ai`](./skills/generate-images-with-firebase-ai) | Generating or editing images with a Gemini image model (Nano Banana) |
| [`firebase-data-connect`](./skills/firebase-data-connect) | Writing GraphQL queries against Data Connect |

### Shipping and product

| Skill | Loads when you're… |
|---|---|
| [`accessibility`](./skills/accessibility) | Working on a11y, WCAG, screen readers, focus order |
| [`inclusive-design`](./skills/inclusive-design) | Handling i18n, global name/address forms, low-end devices |
| [`revenuecat-testing`](./skills/revenuecat-testing) | Testing purchases, subscriptions, sandbox flows, experiment readiness |
| [`developing-genkit-dart`](./skills/developing-genkit-dart) | Building AI agents in Dart with Genkit |

## 🗂️ Rules and combined sets (
````
