accessibility
affaan-m/ecc
Design and audit inclusive digital products using WCAG 2.2 Level AA standards across Web, iOS, and Android.
What is accessibility?
This skill helps you implement accessible interfaces that work for all users, including those using screen readers, keyboard navigation, or switch controls. Use it to generate semantic ARIA for Web and accessibility traits for native platforms, audit existing code for compliance gaps, and map design requirements to technical accessibility attributes.
- Generate semantic ARIA labels, roles, and live regions for Web components
- Define accessibility traits and content descriptions for iOS (SwiftUI) and Android (Compose)
- Audit code against WCAG 2.2 success criteria including target size, focus visibility, and contrast ratios
- Implement focus management, keyboard navigation, and modal focus containment
- Map UI component specifications to cross-platform accessibility patterns
- Verify Name, Role, Value patterns and assistive technology compatibility
How to install accessibility
npx skills add null --skill accessibilityHow to use accessibility
- 1.Identify the functional role of your UI component (button, link, tab, etc.) and use the most semantic native element available
- 2.Define perceivable attributes: ensure 4.5:1 text contrast, add alt text for images, and support up to 400% zoom
- 3.Implement operable controls with minimum 24x24px target size (Web) or 44x44pt (Native) and visible focus indicators
- 4.Ensure understandable logic with consistent patterns, descriptive error messages, and no redundant data entry
- 5.Verify robust compatibility by checking Name/Role/Value patterns and testing with assistive technologies
- 6.Reference the cross-platform mapping table to translate features between Web (ARIA/HTML5), iOS (SwiftUI traits), and Android (Compose semantics)
Use cases
- Defining accessible UI component specs for Web, iOS, or Android platforms
- Auditing existing interfaces for WCAG 2.2 compliance gaps and accessibility barriers
- Implementing new standards like Target Size (Minimum) and Focus Appearance requirements
- Converting design mockups to semantic HTML with proper ARIA attributes
- Ensuring modals trap focus correctly and restore it on close
- Frontend developers building Web applications
- iOS/Android developers using SwiftUI or Compose
- UX/Product designers defining component specifications
- QA engineers auditing accessibility compliance
- Accessibility specialists reviewing code implementations
accessibility FAQ
aria-label provides the primary accessible name for an element (e.g., 'Delete item'), while aria-describedby links to additional descriptive text (e.g., 'Permanently removes this item from your list'). Use aria-label for the main purpose and aria-describedby for supplementary context.
Always provide a descriptive text label via aria-label (Web), accessibilityLabel() (iOS), or contentDescription (Android). Never rely on the icon alone, as screen readers won't know the button's purpose.
Focus containment means keyboard focus cannot escape to background content while a modal is open. It's required by WCAG 2.1.2 and prevents confusion. Modals must trap focus, be escapable via Escape key or close button, and restore focus to the trigger element when closed.
Web: 24x24 CSS pixels (WCAG 2.2 SC 2.5.8). Native platforms: 44x44 points (iOS/Android guidelines). Larger is better for accessibility.
Always use semantic native elements (button, a, input) before custom roles. A div-button requires manual role, keyboard support, and focus management—semantic elements provide these built-in.
Full instructions (SKILL.md)
Source of truth, from affaan-m/ecc.
name: accessibility description: Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA standards. Use this skill to generate semantic ARIA for Web and accessibility traits for Web and Native platforms (iOS/Android). metadata: origin: ECC
Accessibility (WCAG 2.2)
This skill ensures that digital interfaces are Perceivable, Operable, Understandable, and Robust (POUR) for all users, including those using screen readers, switch controls, or keyboard navigation. It focuses on the technical implementation of WCAG 2.2 success criteria.
When to Use
- Defining UI component specifications for Web, iOS, or Android.
- Auditing existing code for accessibility barriers or compliance gaps.
- Implementing new WCAG 2.2 standards like Target Size (Minimum) and Focus Appearance.
- Mapping high-level design requirements to technical attributes (ARIA roles, traits, hints).
Core Concepts
- POUR Principles: The foundation of WCAG (Perceivable, Operable, Understandable, Robust).
- Semantic Mapping: Using native elements over generic containers to provide built-in accessibility.
- Accessibility Tree: The representation of the UI that assistive technologies actually "read."
- Focus Management: Controlling the order and visibility of the keyboard/screen reader cursor.
- Labeling & Hints: Providing context through
aria-label,accessibilityLabel, andcontentDescription.
How It Works
Step 1: Identify the Component Role
Determine the functional purpose (e.g., Is this a button, a link, or a tab?). Use the most semantic native element available before resorting to custom roles.
Step 2: Define Perceivable Attributes
- Ensure text contrast meets 4.5:1 (normal) or 3:1 (large/UI).
- Add text alternatives for non-text content (images, icons).
- Implement responsive reflow (up to 400% zoom without loss of function).
Step 3: Implement Operable Controls
- Ensure a minimum 24x24 CSS pixel target size (WCAG 2.2 SC 2.5.8).
- Verify all interactive elements are reachable via keyboard and have a visible focus indicator (SC 2.4.11).
- Provide single-pointer alternatives for dragging movements.
Step 4: Ensure Understandable Logic
- Use consistent navigation patterns.
- Provide descriptive error messages and suggestions for correction (SC 3.3.3).
- Implement "Redundant Entry" (SC 3.3.7) to prevent asking for the same data twice.
Step 5: Verify Robust Compatibility
- Use correct
Name, Role, Valuepatterns. - Implement
aria-liveor live regions for dynamic status updates.
Accessibility Architecture Diagram
flowchart TD
UI["UI Component"] --> Platform{Platform?}
Platform -->|Web| ARIA["WAI-ARIA + HTML5"]
Platform -->|iOS| SwiftUI["Accessibility Traits + Labels"]
Platform -->|Android| Compose["Semantics + ContentDesc"]
ARIA --> AT["Assistive Technology (Screen Readers, Switches)"]
SwiftUI --> AT
Compose --> AT
Cross-Platform Mapping
| Feature | Web (HTML/ARIA) | iOS (SwiftUI) | Android (Compose) |
|---|---|---|---|
| Primary Label | aria-label / <label> | .accessibilityLabel() | contentDescription |
| Secondary Hint | aria-describedby | .accessibilityHint() | Modifier.semantics { stateDescription = ... } |
| Action Role | role="button" | .accessibilityAddTraits(.isButton) | Modifier.semantics { role = Role.Button } |
| Live Updates | aria-live="polite" | .accessibilityLiveRegion(.polite) | Modifier.semantics { liveRegion = LiveRegionMode.Polite } |
Examples
Web: Accessible Search
<form role="search">
<label for="search-input" class="sr-only">Search products</label>
<input type="search" id="search-input" placeholder="Search..." />
<button type="submit" aria-label="Submit Search">
<svg aria-hidden="true">...</svg>
</button>
</form>
iOS: Accessible Action Button
Button(action: deleteItem) {
Image(systemName: "trash")
}
.accessibilityLabel("Delete item")
.accessibilityHint("Permanently removes this item from your list")
.accessibilityAddTraits(.isButton)
Android: Accessible Toggle
Switch(
checked = isEnabled,
onCheckedChange = { onToggle() },
modifier = Modifier.semantics {
contentDescription = "Enable notifications"
}
)
Anti-Patterns to Avoid
- Div-Buttons: Using a
<div>or<span>for a click event without adding a role and keyboard support. - Color-Only Meaning: Indicating an error or status only with a color change (e.g., turning a border red).
- Uncontained Modal Focus: Modals that don't trap focus, allowing keyboard users to navigate background content while the modal is open. Focus must be contained and escapable via the
Escapekey or an explicit close button (WCAG SC 2.1.2). - Redundant Alt Text: Using "Image of..." or "Picture of..." in alt text (screen readers already announce the role "Image").
Best Practices Checklist
- Interactive elements meet the 24x24px (Web) or 44x44pt (Native) target size.
- Focus indicators are clearly visible and high-contrast.
- Modals contain focus while open, and release it cleanly on close (
Escapekey or close button). - Dropdowns and menus restore focus to the trigger element on close.
- Forms provide text-based error suggestions.
- All icon-only buttons have a descriptive text label.
- Content reflows properly when text is scaled.
References
- WCAG 2.2 Guidelines
- WAI-ARIA Authoring Practices
- iOS Accessibility Programming Guide
- iOS Human Interface Guidelines - Accessibility
- Android Accessibility Developer Guide
Related Skills
frontend-patternsdesign-systemliquid-glass-designswiftui-patterns
Related skills
More from affaan-m/ecc and the wider catalog.
agent-architecture-audit
Full-stack diagnostic for agent and LLM applications—audits 12-layer stack for wrapper regression, memory pollution, and tool discipline failures.
agent-eval
Systematically benchmark coding agents on your tasks with pass rate, cost, time, and consistency metrics.
agent-introspection-debugging
Structured self-debugging workflow for AI agents to diagnose and recover from failures systematically.
agent-payment-x402
Enable AI agents to make policy-gated payments with spending controls and non-custodial wallets via x402 protocol.
agent-self-evaluation
Agent skill from affaan-m/ecc.
agent-sort
Sort ECC components into DAILY vs LIBRARY buckets using repo evidence instead of guessing.