Skills

36 skills across 10 lifecycle groups. Each is a folder with a SKILL.md that follows the Role → Context → Workflow (Step 0 TodoWrite) contract. This table is generated from the real skill frontmatter at build time.

accessibility

Skill	What it does
`a11y-dev`	Accessibility-first development assistant — applies WCAG 2.1/2.2 Level AA semantics, keyboard support, ARIA, and focus management while generating UI code, instead of retrofitting it afterward.
`a11y-fix`	Investigate and repair reported WCAG 2.1/2.2 AA defects — reproduce the original scenario, prove repository and source ownership, test root causes, apply a bounded native-first fix, and verify the exact build and required assistive-technology behavior. Explicit non-fix outcomes when evidence is missing.
`a11y-report`	Consolidate findings from a11y-scan, a11y-review, a11y-fix, and a11y-verify into a single shareable accessibility report — Markdown by default, or a self-contained filterable HTML file — with a WCAG severity/criterion summary. Can optionally file GitHub issues for open findings, gated on explicit approval.
`a11y-review`	Deep, mode-based accessibility review of a live page beyond automated scanning — interactive widgets (keyboard/ARIA/focus), color contrast, color-only meaning, link purpose, display modes (dark/high-contrast/forced-colors), and responsive viewports. Uses Playwright + axe. WCAG 2.1/2.2 AA.
`a11y-scan`	Scan for WCAG 2.1/2.2 Level AA violations — statically over source (markup/components/styles) or at runtime against a live URL using axe-core. Produces a prioritized, deduplicated violation report with WCAG criteria and locations. WCAG-only; no vendor-specific standard.
`a11y-test-gen`	Generate Playwright accessibility tests with axe-core for a component or page — automated WCAG scans plus keyboard-navigation, focus-management, and ARIA/state assertions — so accessibility regressions are caught in CI. WCAG 2.1/2.2 AA.
`a11y-verify`	Verify an accessibility repair on the exact candidate build against the original failing scenario, WCAG checks and required browser/assistive-technology matrix. Returns Fixed, Not fixed, Fixed but new issues, Blocked or Inconclusive with evidence; axe alone is not proof.

architecture

Skill	What it does
`architecture-doc`	Produce or update a lightweight, current architecture document — components and responsibilities, key interfaces/contracts, data model, and how non-functional requirements map to design decisions — grounded in the actual code (via graph-repo). Realizes EASE-MAS A6.
`graph-repo`	Build a queryable code graph of a repository — modules, files, and symbols (functions/classes/exports) with import, call, and dependency edges — exported as JSON plus a Mermaid/HTML visualization. Powers impact analysis for review, refactor, debugging, and bounded repair.
`threat-model`	Produce a STRIDE-based threat model for a system or feature — assets, trust boundaries, data flows, threats per element, and prioritized mitigations mapped to controls — grounded in the actual architecture. Feeds security-review and the design of safe changes.

debugging

Skill	What it does
`analyze-bug`	Turn a raw failure (CI failure, crash, or report) into a structured, deduplicated bug — extract error, stack, logs, artifacts, correlation to the recent diff, and reproduction steps — and link it to the failing test/requirement in the traceability graph. Realizes EASE-MAS A15/A17.
`fix-bug`	Repair a defect under bounded autonomy — take ranked hypotheses, localize and patch, then validate through unit, targeted E2E, regression, and security before an independent repair-validator gate, and open a draft PR (human merges). Enforces max attempts/diff and termination conditions. Realizes EASE-MAS A20–A22 (Algorithms 6/7).
`fix-test`	Repair a failing or incorrect test when the test (not the product) is at fault — wrong assertion, drifted selector, bad fixture/data, or flakiness — without weakening coverage. First decides whether the failure is a real product regression (then it's a bug, not a test fix).
`root-cause`	Given a structured bug, produce ranked root-cause hypotheses (at least k competing causes) each with cited evidence and a confidence score, and flag ambiguity when the top hypothesis isn't clearly ahead. Read-only diagnosis that feeds fix-bug. Realizes EASE-MAS A19 (Algorithm 5).

design

Skill	What it does
`design-spec`	Turn a brief or existing component into a design-system-aligned component spec — anatomy, variants/states, props/API, tokens, interaction, and accessibility requirements — ready for implementation and review. Framework-agnostic; grounded in the project's design tokens.
`from-figma`	Extract a design spec and design tokens from a Figma reference (via the Figma MCP or an exported file/link) and translate them into a design-spec plus token values that match the project's system. Optional integration — degrades gracefully when Figma access is unavailable.

development

Skill	What it does
`implement-change`	Implement a bounded change (a bug fix or a small improvement/feature step) from understanding through reproduction, minimal edit, tests, and local validation — then self-review with the critic agents. Feature-branch, tests required, human merges.
`refactor`	Perform a behavior-preserving refactor — reduce duplication, complexity, or unclear structure — safely, by first ensuring test coverage exists, then changing in small verified steps. No functional change; scope stays within ownership limits.
`start-feature`	Kick off a new feature the right way — turn intent into a spec, validate it, derive a lightweight architecture and an execution plan, get explicit human approval, then scaffold the branch, skeleton, and test stubs. Human-gated at the spec/plan (EASE-MAS A1–A7, permission L2).

devops

Skill	What it does
`fix-ci`	Diagnose and repair a failing CI pipeline — pull the failing run's logs (via the git provider CLI), classify the failure (build/test/lint/flake/infra), find the root cause, and apply a minimal fix or open a targeted follow-up. CLI-first (gh / az) with MCP fallback.
`release-readiness`	Run a release-readiness gate before shipping — verify tests/coverage, quality gates (security, a11y, perf), open blockers, changelog/version, migrations, and rollback plan — and produce a go/no-go report with the evidence. Realizes EASE-MAS A23. Does not deploy.

repo

Skill	What it does
`sweep-codebase`	Run a bounded codebase-hygiene sweep over a chosen scope — dead code, stale TODOs, lint/type issues, small inconsistencies, easy a11y/security nits — collect findings, deliberate, and route only approved, low-risk items to implement-change/refactor as small PRs. Bounded by design; never boils the ocean.

requirements

Skill	What it does
`from-requirements`	Turn raw requirements (a brief, ticket, or conversation) into a structured PRD — goals, user stories with acceptance criteria, scope/non-goals, constraints, and non-functional requirements — and seed the traceability graph with Requirement and PRDItem nodes. Realizes EASE-MAS A1–A4.
`grade-spec`	Grade a PRD/spec for quality before build starts — completeness, testability, clarity, scope discipline, and NFR coverage — with a scored rubric and specific fixes. Blocks weak specs from entering the build loop. Realizes EASE-MAS A5.

review

Skill	What it does
`code-review`	Run a roster-driven, multi-specialist review of a code change (diff/PR). Selects the relevant critic agents by what the change touches, collects severity-tagged findings, de-duplicates, then hands them to `deliberate` for a verdict. Read-only — posts a review, never merges.
`deliberate`	Evaluate a set of review findings and render a decision per finding and overall — Take Action, Stand Down, Defer, or Escalate — using evidence and severity, not majority vote. Used by code-review and sweep-codebase.
`pr-learn`	Extract durable, reusable lessons from merged PRs (and their reviews) — recurring bug patterns, missed test cases, review blind spots, conventions — and record them in shared memory so future reviews and changes improve.

testing

Skill	What it does
`coverage-gap`	Find where tests are missing — requirements/acceptance criteria with no linked test, code paths/branches not exercised, and untested error/edge cases — and produce a prioritized gap report that feeds test-plan/author-test.
`flaky-test`	Detect non-deterministic (flaky) tests from run history, classify the cause (timing/order/network/data/environment), quarantine to unblock CI, and propose or apply a durable fix — distinct from a real product failure. Realizes EASE-MAS A16 + failure classification (Algorithm 4).
`test-plan`	Turn a requirement/PRD into an executable, risk-based test plan — strategy, scenarios per acceptance criterion, and canonical test cases (id, requirement link, preconditions, steps, assertions) with traceability. Feeds author-test/a11y-test-gen. Realizes EASE-MAS A10–A12.
`validate-scenario`	Validate one test against its source scenario/requirement and return a verdict — Keep, UpdateTest, CreateTest, Deprecate, or Investigate — with an effort estimate and evidence, using a step-by-step comparison and a semantic-drift signal. Can author or fix the test on request.

testing/playwright

Skill	What it does
`author-test`	Author a Playwright test (unit-of-behavior or user journey) for a component, page, or requirement. Uses the Playwright MCP for interactive selector/snapshot discovery and the CLI to run the new test once. Links the test to its requirement in the traceability graph (EASE-MAS A13).
`playwright-auth`	Authenticate against a configured test environment and save a reusable Playwright storage-state file (cookies/localStorage) so other Playwright skills can run authenticated tests without logging in each time. Supports none/storage-state/basic/cert/oidc auth from config.test_environments.
`run-tests`	Execute Playwright tests deterministically via the CLI against a configured environment, collect artifacts (trace/video/screenshot/DOM/console/network), parse results, and record an Execution (and any Failures) in the traceability graph. This is the authoritative test runner (EASE-MAS A14).
`update-test`	Update a Playwright test that has drifted from the current UI or requirement — fix selectors, assertions, fixtures, or flow so it once again asserts the intended behavior, without weakening it. Preserves the requirement link.
`verify-test`	Verify a Playwright test is correct and non-flaky — it asserts the right behavior, passes for the right reason, fails when the behavior breaks, and is stable across repeated runs. Reports a verdict with evidence.

Architecture Agents