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
