Get the FREE Ultimate OpenClaw Setup Guide →

react-best-practices

npx machina-cli add skill tech-leads-club/agent-skills/react-best-practices --openclaw
Files (1)
SKILL.md
6.3 KB

Vercel React Best Practices

Comprehensive performance optimization guide for React and Next.js applications, maintained by Vercel. Contains 57 rules across 8 categories, prioritized by impact to guide automated refactoring and code generation.

When to Apply

Reference these guidelines when:

  • Writing new React components or Next.js pages
  • Implementing data fetching (client or server-side)
  • Reviewing code for performance issues
  • Refactoring existing React/Next.js code
  • Optimizing bundle size or load times

Rule Categories by Priority

PriorityCategoryImpactPrefix
1Eliminating WaterfallsCRITICALasync-
2Bundle Size OptimizationCRITICALbundle-
3Server-Side PerformanceHIGHserver-
4Client-Side Data FetchingMEDIUM-HIGHclient-
5Re-render OptimizationMEDIUMrerender-
6Rendering PerformanceMEDIUMrendering-
7JavaScript PerformanceLOW-MEDIUMjs-
8Advanced PatternsLOWadvanced-

Quick Reference

1. Eliminating Waterfalls (CRITICAL)

  • async-defer-await - Move await into branches where actually used
  • async-parallel - Use Promise.all() for independent operations
  • async-dependencies - Use better-all for partial dependencies
  • async-api-routes - Start promises early, await late in API routes
  • async-suspense-boundaries - Use Suspense to stream content

2. Bundle Size Optimization (CRITICAL)

  • bundle-barrel-imports - Import directly, avoid barrel files
  • bundle-dynamic-imports - Use next/dynamic for heavy components
  • bundle-defer-third-party - Load analytics/logging after hydration
  • bundle-conditional - Load modules only when feature is activated
  • bundle-preload - Preload on hover/focus for perceived speed

3. Server-Side Performance (HIGH)

  • server-auth-actions - Authenticate server actions like API routes
  • server-cache-react - Use React.cache() for per-request deduplication
  • server-cache-lru - Use LRU cache for cross-request caching
  • server-dedup-props - Avoid duplicate serialization in RSC props
  • server-serialization - Minimize data passed to client components
  • server-parallel-fetching - Restructure components to parallelize fetches
  • server-after-nonblocking - Use after() for non-blocking operations

4. Client-Side Data Fetching (MEDIUM-HIGH)

  • client-swr-dedup - Use SWR for automatic request deduplication
  • client-event-listeners - Deduplicate global event listeners
  • client-passive-event-listeners - Use passive listeners for scroll
  • client-localstorage-schema - Version and minimize localStorage data

5. Re-render Optimization (MEDIUM)

  • rerender-defer-reads - Don't subscribe to state only used in callbacks
  • rerender-memo - Extract expensive work into memoized components
  • rerender-memo-with-default-value - Hoist default non-primitive props
  • rerender-dependencies - Use primitive dependencies in effects
  • rerender-derived-state - Subscribe to derived booleans, not raw values
  • rerender-derived-state-no-effect - Derive state during render, not effects
  • rerender-functional-setstate - Use functional setState for stable callbacks
  • rerender-lazy-state-init - Pass function to useState for expensive values
  • rerender-simple-expression-in-memo - Avoid memo for simple primitives
  • rerender-move-effect-to-event - Put interaction logic in event handlers
  • rerender-transitions - Use startTransition for non-urgent updates
  • rerender-use-ref-transient-values - Use refs for transient frequent values

6. Rendering Performance (MEDIUM)

  • rendering-animate-svg-wrapper - Animate div wrapper, not SVG element
  • rendering-content-visibility - Use content-visibility for long lists
  • rendering-hoist-jsx - Extract static JSX outside components
  • rendering-svg-precision - Reduce SVG coordinate precision
  • rendering-hydration-no-flicker - Use inline script for client-only data
  • rendering-hydration-suppress-warning - Suppress expected mismatches
  • rendering-activity - Use Activity component for show/hide
  • rendering-conditional-render - Use ternary, not && for conditionals
  • rendering-usetransition-loading - Prefer useTransition for loading state

7. JavaScript Performance (LOW-MEDIUM)

  • js-batch-dom-css - Group CSS changes via classes or cssText
  • js-index-maps - Build Map for repeated lookups
  • js-cache-property-access - Cache object properties in loops
  • js-cache-function-results - Cache function results in module-level Map
  • js-cache-storage - Cache localStorage/sessionStorage reads
  • js-combine-iterations - Combine multiple filter/map into one loop
  • js-length-check-first - Check array length before expensive comparison
  • js-early-exit - Return early from functions
  • js-hoist-regexp - Hoist RegExp creation outside loops
  • js-min-max-loop - Use loop for min/max instead of sort
  • js-set-map-lookups - Use Set/Map for O(1) lookups
  • js-tosorted-immutable - Use toSorted() for immutability

8. Advanced Patterns (LOW)

  • advanced-event-handler-refs - Store event handlers in refs
  • advanced-init-once - Initialize app once per app load
  • advanced-use-latest - useLatest for stable callback refs

How to Use

Read individual rule files for detailed explanations and code examples:

rules/async-parallel.md
rules/bundle-barrel-imports.md

Each rule file contains:

  • Brief explanation of why it matters
  • Incorrect code example with explanation
  • Correct code example with explanation
  • Additional context and references

Full Compiled Document

For the complete guide with all rules expanded: AGENTS.md

Source

git clone https://github.com/tech-leads-club/agent-skills/blob/main/packages/skills-catalog/skills/(quality)/react-best-practices/SKILL.mdView on GitHub

Overview

A comprehensive set of performance optimization guidelines for React and Next.js, maintained by Vercel Engineering. Use these rules when writing, reviewing, or refactoring code to apply high-impact performance patterns and reduce load times and bundle sizes.

How This Skill Works

The skill organizes guidance into 8 priority categories with named prefixes (e.g., async-, bundle-, server-, client-, rerender-, rendering-, js-, advanced-). It includes 57 rules to guide automated refactoring and code generation, helping you implement performance-first patterns across components, pages, data fetching, and bundles.

When to Use It

  • Writing new React components or Next.js pages
  • Implementing client or server-side data fetching
  • Reviewing code for performance issues
  • Refactoring existing React/Next.js code
  • Optimizing bundle size or perceived load times

Quick Start

  1. Step 1: Identify bottlenecks using the 8 priority categories and locate opportunities (e.g., waterfalls, large bundles, repeated fetches).
  2. Step 2: Apply the relevant prefixes (async-, bundle-, server-, client-, rerender-) to implement concrete changes in code and structure.
  3. Step 3: Measure impact with performance metrics and iterate until load times and interactivity improve.

Best Practices

  • async-defer-await, async-parallel, async-api-routes: eliminate waterfalls to start work earlier and resolve promises in the right branches
  • bundle-barrel-imports, bundle-dynamic-imports, bundle-defer-third-party: minimize bundle size by direct imports, dynamic loading, and deferring non-critical analytics
  • server-cache-react, server-cache-lru, server-serialization: use per-request caching and efficient serialization to reduce server load and data transfer
  • client-swr-dedup, client-event-listeners, client-passive-event-listeners: deduplicate fetches and optimize event handling on the client
  • rerender-memo, rerender-dependencies, rerender-functional-setstate: memoize expensive work and stabilize dependencies to reduce re-renders

Example Use Cases

  • Split heavy components with bundle-dynamic-imports to avoid initial bundle bloat
  • Move data fetching to parallel branches using async-parallel for independent requests
  • Introduce SWR with client-swr-dedup to prevent duplicate requests
  • Cache server responses with server-cache-react to deduplicate similar requests
  • Extract expensive calculations into memoized components using rerender-memo

Frequently Asked Questions

Add this skill to your agents
Sponsor this space

Reach thousands of developers