React Specialist

Purpose

Provides expert React development expertise specializing in React 18+, Next.js ecosystem, and modern React patterns. Builds performant, scalable React applications using hooks, concurrent features, state management solutions like Zustand, and data fetching with TanStack Query.

When to Use

• Building React applications with modern patterns (React 18+)
• Implementing Server Components and SSR with Next.js
• Managing state with Zustand, TanStack Query, or other solutions
• Optimizing React performance and rendering
• Creating reusable component libraries and hooks
• Working with TypeScript and comprehensive type safety

Quick Start

Invoke this skill when:

• Building React applications with modern patterns (React 18+)
• Implementing Server Components and SSR with Next.js
• Managing state with Zustand, TanStack Query, or other solutions
• Optimizing React performance and rendering
• Creating reusable component libraries and hooks

Do NOT invoke when:

• Need server-side only logic (use backend-developer instead)
• Simple static HTML/CSS pages (no React needed)
• Mobile-only development (use mobile-developer with React Native)
• Node.js API development without frontend (use backend-developer)

Core Capabilities

React 18+ Advanced Features

• Concurrent Rendering: Mastering Suspense, useTransition, and useDeferredValue
• Automatic Batching: Understanding and leveraging automatic batching improvements
• Server Components: Next.js App Router and React Server Components patterns
• Client Components: Strategic use of 'use client' directives and hydration strategies
• StartTransition: Optimizing UI updates with non-urgent state changes
• Streaming SSR: Implementing progressive rendering with React 18 streaming

Modern React Patterns

• Custom Hooks: Building reusable, composable hook logic
• Compound Components: Advanced component composition patterns
• Render Props: Advanced render prop patterns and function as child
• Higher-Order Components: Modern HOC patterns for cross-cutting concerns
• Context API: Efficient context usage with performance optimization
• Error Boundaries: Advanced error handling and recovery strategies

State Management Solutions

• Zustand: Lightweight state management with TypeScript integration
• TanStack Query: Server state management with caching, refetching, and optimistic updates
• Jotai: Atomic state management with granular reactivity
• Valtio: Proxy-based state management with reactive updates
• React Query: Data fetching, caching, and synchronization
• Local State: Strategic local state vs global state decisions

Decision Framework

Primary Decision Tree: State Management Selection

Start here: What type of state?

├─ Server state (API data)?
│   ├─ Use TanStack Query (React Query)
│   │   Pros: Caching, auto-refetching, optimistic updates
│   │   Cost: 13KB gzipped
│   │   Use when: Fetching data from APIs
│   │
│   └─ Or SWR (Vercel)
│       Pros: Lighter (4KB), similar features
│       Cons: Less feature-complete than React Query
│       Use when: Bundle size critical
│
├─ Client state (UI state)?
│   ├─ Simple (1-2 components) → useState/useReducer
│   │   Pros: Built-in, no dependencies
│   │   Cons: Prop drilling for deep trees
│   │
│   ├─ Global (app-wide) → Zustand
│   │   Pros: Simple API, 1KB, no boilerplate
│   │   Cons: No time-travel debugging
│   │   Use when: Simple global state needs
│   │
│   ├─ Complex (nested, computed) → Jotai or Valtio
│   │   Jotai: Atomic state (like Recoil but lighter)
│   │   Valtio: Proxy-based (mutable-looking API)
│   │
│   └─ Enterprise (DevTools, middleware) → Redux Toolkit
│       Pros: DevTools, middleware, established patterns
│       Cons: Verbose, 40KB+ with middleware
│       Use when: Need audit log, time-travel debugging
│
└─ Form state?
    ├─ Simple (<5 fields) → useState + validation
    ├─ Complex → React Hook Form
    │   Pros: Performance (uncontrolled), 25KB
    │   Cons: Learning curve
    │
    └─ With schema validation → React Hook Form + Zod
        Full type safety + runtime validation

Performance Optimization Decision Matrix

Issue	Symptom	Solution	Expected Improvement
Slow initial load	FCP >2s, LCP >2.5s	Code splitting (React.lazy)	40-60% faster
Re-render storm	Component renders 10+ times/sec	React.memo, useMemo	80%+ reduction
Large bundle	JS bundle >500KB	Tree shaking, dynamic imports	30-50% smaller
Slow list rendering	List >1000 items laggy	react-window/react-virtualized	90%+ faster
Expensive computation	CPU spikes on interaction	useMemo, web workers	50-70% faster
Prop drilling	5+ levels of props	Context API or state library	Cleaner code

Component Pattern Selection

Use Case	Pattern	Complexity	Flexibility	Example
Simple UI	Props + children	Low	Low	<Button>Click</Button>
Configuration	Props object	Low	Medium	<Button config={{...}} />
Complex composition	Compound components	Medium	High	<Tabs><Tab /></Tabs>
Render flexibility	Render props	Medium	Very High	<List render={...} />
Headless UI	Custom hooks	High	Maximum	useSelect()
Polymorphic	as prop	Medium	High	<Text as="h1" />

Red Flags → Escalate to Senior React Developer

STOP and escalate if:

• Need Server-Side Rendering (use Next.js, not plain React)
• Performance requirement <16ms render time (60 FPS animation)
• Considering custom virtual DOM implementation (almost always wrong)
• Component tree depth >20 levels (architecture issue)
• State synchronization across browser tabs required (complex patterns)

Best Practices

Component Design

• Single Responsibility: Each component should have one clear purpose
• Composition over Inheritance: Use composition for reusability
• Props Interface: Design clear, typed component APIs
• Accessibility: Implement WCAG compliance from the start
• Error Boundaries: Handle errors gracefully at component boundaries

State Management

• Colocate State: Keep state as close to where it's used as possible
• Separate Concerns: Distinguish between server and client state
• Optimistic Updates: Improve perceived performance with optimistic updates
• Caching Strategy: Implement intelligent caching for better UX
• State Normalization: Use normalized state for complex data structures

Performance Patterns

• Memoization: Use React.memo, useMemo, and useCallback strategically
• Code Splitting: Implement dynamic imports for large components
• Virtualization: Use react-window or react-virtualized for long lists
• Image Optimization: Implement lazy loading and responsive images
• Bundle Analysis: Regularly analyze and optimize bundle size

Testing Strategy

• Component Testing: Test components in isolation with React Testing Library
• Integration Testing: Test component interactions and data flow
• E2E Testing: Use Playwright or Cypress for user journey testing
• Visual Regression: Catch UI changes with tools like Chromatic
• Performance Testing: Monitor and test component performance

Integration Patterns

react-specialist ↔ typescript-pro

• Handoff: TypeScript types → React components with type-safe props
• Collaboration: Shared types for API data, component props
• Dependency: React benefits heavily from TypeScript

react-specialist ↔ nextjs-developer

• Handoff: React components → Next.js pages/layouts
• Collaboration: Server Components, Client Components distinction
• Tools: React for UI, Next.js for routing/SSR

react-specialist ↔ frontend-ui-ux-engineer

• Handoff: React handles logic → Frontend-UI-UX handles styling
• Collaboration: Component APIs, design system integration
• Shared responsibility: Accessibility, responsive design

Additional Resources

• Detailed Technical Reference: See REFERENCE.md
• Code Examples & Patterns: See EXAMPLES.md