Skip to main content
skill CX Codex

qe-visual-accessibility — Claude Code skill: overview and setup

qe-visual-accessibility runs WCAG 2.2 accessibility audits and catches UI regressions through pixel-diff screenshot comparisons. It validates responsive layouts after CSS or component changes.

MIT 1 installs ★ 533 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add proffesor-for-testing/agentic-qe --skill qe-visual-accessibility -a claude-code
Open on GitHub

What qe-visual-accessibility does

The skill guides automated screenshot capture, pixel-diff comparisons between environments, and accessibility checks via axe-core. It verifies contrast ratios, keyboard navigation, and ARIA markup against WCAG 2.2 criteria.

Browser actions depend on the Vibium engine from the qe-browser skill. Without running aqe init to install the vibium binary, automated browser tasks will fail. The pixel diff script lets you set precision limits with --threshold and skip changing page areas using selector filters.

What it helps with

  • Detect UI layout regressions after component updates
  • Run automated WCAG 2.2 AA accessibility audits
  • Verify responsive viewports on mobile, tablet, and desktop sizes
  • Ignore dynamic timestamps in pixel comparisons via selectors

Example prompts for the agent

  • Run an accessibility audit on https://example.com using the WCAG 2.2 AA standard.
  • Compare staging against production using aqe visual test.
  • Test responsive layouts for https://example.com across all viewports.

How to install qe-visual-accessibility

1Skills CLI (Vercel)

npx skills add proffesor-for-testing/agentic-qe --skill qe-visual-accessibility -a claude-code

2Manually: put the files in place

~/.claude/skills/qe-visual-accessibility/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/qe-visual-accessibility/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about qe-visual-accessibility

How do I install qe-visual-accessibility in Claude Code?

Run npx skills add proffesor-for-testing/agentic-qe --skill qe-visual-accessibility -a claude-code. The file will be placed at ~/.claude/skills/qe-visual-accessibility/SKILL.md.

What does qe-visual-accessibility do?

It coordinates agents to capture screenshots, calculate pixel diffs, check responsive layouts, and audit WCAG 2.2 compliance.

Which browser engine is required?

All automation relies on the Vibium engine provided by qe-browser. You must install the vibium binary beforehand using aqe init.

Source text

SKILL.md · MIT
---
name: "qe-visual-accessibility"
description: "Captures and compares screenshots across viewports, runs axe-core accessibility scans, and detects visual regressions with pixel-diff analysis. Use when detecting UI regressions, validating responsive layouts, testing WCAG compliance, or ensuring visual consistency after CSS or component changes."
trust_tier: 3
validation:
  schema_path: schemas/output.json
  validator_path: scripts/validate-config.json
  eval_path: evals/qe-visual-accessibility.yaml
---

# QE Visual Accessibility

## Purpose

Guide the use of v3's visual and accessibility testing capabilities including screenshot comparison, responsive design validation, and WCAG 2.2 compliance verification.

## Activation

- When testing visual appearance
- When validating responsive design
- When checking accessibility compliance
- When detecting visual regressions
- When testing cross-browser rendering

## Quick Start

```bash
# Visual regression test
aqe visual test --baseline production --current staging

# Responsive design test
aqe visual responsive --url https://example.com --viewports all

# Accessibility audit
aqe a11y audit --url https://example.com --standard wcag22-aa

# Cross-browser test
aqe visual cross-browser --url https://example.com --browsers chrome,firefox,safari
```

## Agent Workflow

```typescript
// Visual regression testing
Task("Run visual regression", `
  Compare staging against production:
  - Capture screenshots of key pages
  - Detect pixel differences
  - Flag significant visual changes
  - Generate visual diff report
`, "qe-visual-tester")

// Accessibility audit
Task("Audit accessibility", `
  Run WCAG 2.2 AA compliance audit:
  - Check color contrast ratios
  - Verify keyboard navigation
  - Test screen reader compatibility
  - Validate ARIA labels
  Generate compliance report with fix suggestions.
`, "qe-accessibility-agent")
```

## Browser engine

All browser automation in this skill uses the **qe-browser** fleet skill (Vibium engine). See `.claude/skills/qe-browser/SKILL.md`. The `vibium` binary is installed by `aqe init`.

## Visual Testing Operations

### 1. Visual Regression (via qe-browser)

```bash
# Establish baselines for the pages we care about
for path in / /login /dashboard /settings; do
  slug=$(echo "$path" | tr '/' '_' | sed 's/^_//' || echo root)
  vibium go "https://production.example.com$path" && vibium wait load
  node .claude/skills/qe-browser/scripts/visual-diff.js --name "baseline_${slug:-root}"
done

# Compare staging against those baselines
for path in / /login /dashboard /settings; do
  slug=$(echo "$path" | tr '/' '_' | sed 's/^_//' || echo root)
  vibium go "https://staging.example.com$path" && vibium wait load
  node .claude/skills/qe-browser/scripts/visual-diff.js \
    --name "baseline_${slug:-root}" --threshold 0.001  # 0.1% pixel diff
done
```

Ignore dynamic regions (timestamps, live counts) by scoping the diff to a selector that excludes them:

```bash
node .claude/skills/qe-browser/scripts/visual-diff.js \
  --name hero --selector "main > .content"
```

Legacy programmatic TypeScript API (still available for tests that prefer it over shelling out):

```typescript
await visualTester.compareScreenshots({
  baseline: {
    source: 'production',
    pages: ['/', '/login', '/dashboard', '/settings']
  },
  current: {
    source: 'staging',
    pages: ['/', '/login', '/dashboard', '/settings']
  },
  comparison: {
    threshold: 0.1,  // 0.1% pixel difference
    antialiasing: true,
    ignoreRegions: ['#dynamic-content', '.timestamp']
  }
});
```

### 2. Responsive Testing

```typescript
await responsiveTester.test({
  url: 'https://example.com',
  viewports: [
    { name: 'mobile', width: 375, height: 667 },
    { name: 'tablet', width: 768, height: 1024 },
    { name: 'desktop', width: 1920, height: 1080 }
  ],
  checks: {
    layoutShift: true,
    contentOverflow: true,
    touchTargets: true,
    fontScaling: true
  }
});
```

### 3. Accessibility Audit

```typescript
await accessibilityAgent.audit({
  url: 'https://example.com',
  standard: 'WCAG22-AA',
  checks: {
    perceivable: {
      colorContrast: true,
      textAlternatives: true,
      captions: true
    },
    operable: {
      keyboardAccessible: true,
      noTimingIssues: true,
      navigable: true
    },
    understandable: {
      readable: true,
      predictable: true,
      inputAssistance: true
    },
    robust: {
      compatible: true,
      parseErrors: true
    }
  }
});
```

### 4. Cross-Browser Testing

```typescript
await visualTester.crossBrowser({
  url: 'https://example.com',
  browsers: ['chrome', 'firefox', 'safari', 'edge'],
  versions: 'latest-2',
  comparisons: {
    betweenBrowsers: true,
    betweenVersions: true,
    againstBaseline: true
  }
});
```

## WCAG 2.2 Checklist

| Level | Criteria | Auto-Testable |
|-------|----------|---------------|
| A | Non-text Content | ✅ |
| A | Info and Relationships | Partial |
| A | Color Contrast (4.5:1) | ✅ |
| A | Keyboard Accessible | ✅ |
| A | Focus Visible | ✅ |
| AA | Reflow | ✅ |
| AA | Text Spacing | ✅ |
| AAA | Enhanced Contrast (7:1) | ✅ |

## Visual Test Report

```typescript
interface VisualReport {
  summary: {
    pagesCompared: number;
    differencesFound: number;
    passRate: number;
  };
  comparisons: {
    page: string;
    viewport: string;
    baseline: string;
    current: string;
    diff: string;
    diffPercentage: number;
    status: 'pass' | 'fail' | 'review';
  }[];
  accessibility: {
    violations: A11yViolation[];
    passes: number;
    incomplete: number;
    score: number;
  };
  responsive: {
    viewport: string;
    issues: ResponsiveIssue[];
  }[];
}
```

## Accessibility Report

```typescript
interface AccessibilityReport {
  summary: {
    score: number;
    violations: number;
    warnings: number;
    passes: number;
  };
  violations: {
    id: string;
    impact: 'critical' | 'serious' | 'moderate' | 'minor';
    description: string;
    wcag: string[];
    elements: {
      selector: string;
      html: string;
      issue: string;
      fix: string;
    }[];
  }[];
  compliance: {
    wcagLevel: 'A' | 'AA' | 'AAA';
    criteriasMet: number;
    criteriasTotal: number;
  };
}
```

## CI/CD Integration

```yaml
visual_testing:
  on_pr:
    - capture_screenshots
    - compare_to_baseline
    - run_a11y_audit

  thresholds:
    visual_diff: 0.1
    a11y_violations: 0

  artifacts:
    - screenshots/
    - diffs/
    - a11y-report.html
```

## Coordination

**Primary Agents**: qe-visual-tester, qe-accessibility-agent, qe-responsive-tester
**Coordinator**: qe-visual-coordinator
**Related Skills**: qe-test-execution, qe-quality-assessment

© proffesor-for-testing · MIT · proffesor-for-testing/agentic-qe

Similar skills

All skills for Testing and QA →

From the same set73

The whole set →
qcsd-cicd-swarm The qcsd-cicd-swarm Claude Code skill checks CI/CD pipelines before release and assesses deployment readiness. It reviews regression risk and flaky tests, then returns a RELEASE, REMEDIATE, or BLOCK decision. CX Codex +1 104installs test-idea-rewriting test-idea-rewriting is a Claude Code skill that turns passive test descriptions into active actions with observable results. It runs when test ideas are vague or fail quality validation. CX Codex +1 104installs cicd-pipeline-qe-orchestrator The cicd-pipeline-qe-orchestrator skill assigns quality checks and QE agents to CI/CD stages, from commit through production. Use it to plan pipeline testing and define release gates. CX Codex +1 1installs accessibility-testing accessibility-testing — a skill with checklists and test snippets for checking keyboard navigation, color contrast and screen reader support against WCAG 2.2. CX Codex +1 1installs exploratory-testing-advanced exploratory-testing-advanced is a Claude Code skill for planning exploratory sessions, investigating bugs, and recording defects. It supports checks of new features and issues automated tests miss. CX Codex +1 1installs compliance-testing compliance-testing is a skill that checks an app against GDPR, CCPA, HIPAA, SOC2, and PCI-DSS, and tests user rights, encryption, and access logs before audits or during work with personal data. CX Codex +1 1installs quality-metrics Tracks software quality metrics like defect density, DORA indicators, MTTD, and bug escape rates for CI quality gates. CX Codex +1 1installs bug-reporting-excellence The bug-reporting-excellence skill guides an agent through clear bug reports with reproduction steps, environment details, and impact. Use it when documenting defects or setting reporting standards for a team. CX Codex +1 1installs

Project sponsors

Companies that keep this analytics open