react-rtk

Project health audit across 5 categories with parallel specialist agents. Scores architecture, performance, security, tests, accessibility.

Analyze module boundaries — circular imports, feature coupling, barrel file bloat, dead exports. Maps the actual dependency graph.

Adversarial review — stress-test with edge cases, race conditions, accessibility failures, performance bottlenecks. The "grill me" mode.

Capture solved problem as reusable knowledge in .claude/solutions/. Makes patterns available for future sessions.

Design system initialization, audit, and management. Scans project for existing design tokens and generates references for the uiux-designer agent.

Generate documentation — JSDoc/TSDoc for components, README sections, ADRs, Storybook stories. Reads existing code and produces missing docs.

Full autonomous cycle — plan with parallel research, implement with verification, review with 4 parallel agents, capture learnings. Use for medium-to-large features.

Interactive tutorial walkthrough — commands, agents, workflow, Iron Laws. ~3 minutes.

Structured bug debugging with parallel investigation tracks — state, rendering, network, and environment.

Capture a lesson learned as a reusable rule. Updates common-mistakes.md so the same mistake is prevented in future sessions.

Create sprint-based implementation spec with parallel research, Iron Law pre-checks, demoable outcomes per sprint, and approval gate. Replaces separate spec/plan workflows.

Audit component props and state — oversized props, missing defaults, state that should live elsewhere, effect dependency issues.

Fast implementation — skip planning ceremony. For small tasks that don't need parallel research.

Detect unnecessary re-render patterns — the React equivalent of N+1 queries. Finds components that re-render when they shouldn't.

Research React/frontend topics using web search — library comparison, API patterns, migration guides. Produces structured findings.

5-agent parallel code review — idioms, security, tests, verification, design. Produces consolidated report with blocker/warning/suggestion severity.

Scan for technical debt — deprecated patterns, TODO/FIXME comments, outdated deps, inconsistent patterns, refactoring opportunities.

Trace component render paths, prop drilling chains, and state flow. Builds visual dependency trees to find unnecessary re-renders and tight coupling.

Interactive triage of review findings — prioritize, group, and assign severity. Converts raw review output into an actionable fix plan.

Run full verification — TypeScript, ESLint, Prettier, tests, build.

Execute spec sprint-by-sprint, task-by-task with Iron Law checks and verification after each task. Finds first incomplete task and continues.

WCAG 2.2 compliance, ARIA patterns, keyboard navigation, screen reader testing, focus management, color contrast.

Discovers existing patterns, conventions, and architecture in the codebase. ALWAYS spawned during planning. Finds what's already there so agents don't reinvent or contradict.

Compresses multi-agent output to prevent context window overflow. Reads all worker files, applies size-based compression, deduplicates findings, writes consolidated summary.

Coordinate 4 parallel investigation tracks to diagnose complex React bugs. Spawned by /rx:investigate for bugs spanning state, rendering, network, and environment.

Analyze import graph for circular dependencies, feature coupling, barrel file bloat, dead exports. Lightweight scanning agent used by /rx:boundaries.

Pattern-based Iron Law violation detection. Scans diffs and files for violations of non-negotiable rules defined in CLAUDE.md.

Evaluate npm packages for quality, maintenance, security, and project fit. Used by planning-orchestrator for new dependency decisions and /rx:research --compare.

Coordinates 5-agent parallel code review. Spawns react-reviewer, security-analyzer, testing-reviewer, verification-runner, and uiux-designer. Deduplicates findings via context-supervisor.

React rendering performance, bundle size, Core Web Vitals, memoization strategy, code splitting, lazy loading.

Coordinates parallel research agents, then produces sprint-based implementation spec with demoable outcomes per sprint. Replaces separate /spec and /plan workflows.

Component architecture, hooks design, rendering optimization, composition patterns. Invoked for any UI structure decisions.

Code idioms review — React patterns, TypeScript usage, component composition, hook patterns, error handling.

Redux Toolkit state architecture, RTK Query API design, selectors, middleware, normalization. Invoked for any state management decisions.

Trace component render paths, prop flow, and state subscriptions. Builds dependency trees showing re-render cascades. Used by /rx:trace.

Frontend security analysis — XSS, CSRF, auth patterns, secrets exposure, URL parameter injection, dependency vulnerabilities.

State management architecture — where state lives, normalization design, data flow between components, cache strategy. For major state refactors or new feature domains.

Test quality, coverage analysis, RTL patterns, MSW handlers, integration test design. Reviews test code and identifies coverage gaps.

Design system architecture, visual hierarchy, spacing systems, color theory, responsive design, interaction patterns, motion design. Invoked for any visual/interaction decisions.

Runs TypeScript compiler, ESLint, Prettier, and test suite. Reports pass/fail with specific errors.

Research React ecosystem topics — npm packages, patterns, migration guides, known issues. Invoked when feature involves unfamiliar technology or library evaluation.

Full lifecycle coordinator for React/RTK features. Spawns planning, work, review, and compound phases. Use for /rx:full command.

WCAG accessibility patterns — semantic HTML, ARIA, focus management, keyboard navigation. Use when working with aria attributes, role attributes, dialog/nav elements, form elements, or focus management code.

Detect user intent from their first message and suggest the appropriate /rx: workflow command. Loaded automatically on session start.

React performance patterns — memoization, code splitting, RTK Query cache tuning, Core Web Vitals. Use when working with React.memo, useMemo, useCallback, lazy loading, or optimizing render performance.

React component patterns, hooks rules, composition patterns. Use when editing .tsx/.jsx files, working in components/ or hooks/ directories, or creating new React components.

Redux Toolkit and RTK Query patterns. Use when editing slice files, API definitions, store configuration, selectors, or any file importing from @reduxjs/toolkit.

React Testing Library, MSW, and component/hook testing patterns. Use when editing test files (.test.tsx, .test.ts, .spec.tsx), test utilities, or MSW handlers.

UI/UX design system patterns — spacing scale, typography, color tokens, component states, responsive breakpoints, z-index, motion. Use when editing CSS modules, styled components, style directories, theme files, design tokens, tailwind config, or UI primitives.

13 hooks across 4 events