react-specialist

Analyze React 18+ applications for performance bottlenecks and architectural inefficiencies.

68|6|Updated Apr 16, 2020
One-click install
npx skills add https://github.com/zenobi-us/dotfiles --skill react-specialist
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: react-specialist
Source: https://github.com/zenobi-us/dotfiles/tree/main/devtools/files/opencode/skills/react-specialist
Command: npx skills add https://github.com/zenobi-us/dotfiles --skill react-specialist

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solves? Developing high-performance, scalable React applications requires deep expertise in modern patterns, state management, and optimization techniques, often leading to complex code and suboptimal user experiences.

Core Features & Use Cases

  • Performance Optimization: Masters React.memo, useMemo, useCallback, code splitting, and concurrent features for blazing-fast UIs.
  • Advanced State Management: Implements Redux Toolkit, Zustand, Jotai, or Recoil patterns for predictable and scalable state.
  • Production-Ready Architecture: Designs component structures, routing strategies, and build configurations for maintainable, high-quality applications.
  • Use Case: Your React application is experiencing slow load times and poor Core Web Vitals. Use this Skill to analyze component re-renders, implement React.memo and useCallback strategically, and optimize bundle size through code splitting, significantly boosting performance.

Quick Start

Use the react-specialist skill to analyze your main dashboard component for performance bottlenecks and suggest optimizations.

Frequently Asked Questions about react-specialist

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I optimize React component performance and reduce re-renders?

Optimize React performance by strategically applying React.memo, useMemo, and useCallback to prevent unnecessary re-renders, combined with code splitting and concurrent features. Analyze your component structure for bottlenecks, implement memoization selectively, and measure Core Web Vitals improvements with React DevTools.

What's the best way to manage state in large-scale React applications?

State management in React scales with Redux Toolkit, Zustand, Jotai, or Recoil, each offering predictable, centralized state handling. Choose based on complexity: Redux Toolkit for enterprise patterns, Zustand for lightweight needs, and Jotai or Recoil for atomic state. Design for maintainability and TypeScript strict mode compliance.

How can I improve Core Web Vitals and bundle size in my React 18 app?

Improve Core Web Vitals through code splitting, lazy loading, and bundle optimization with Webpack or Vite. Profile component re-renders with React DevTools, eliminate dead code, and configure your build tool for production-grade output. Test with Cypress and ensure accessibility compliance alongside performance gains.

Can I use React hooks with server components for production architectures?

React 18+ supports advanced hook patterns within production-ready architectures combining server components and client-side optimization. Use hooks for state, effects, and performance tuning; structure your routing and component hierarchy for maintainability. Integrate with Vite or Webpack, Jest for testing, and TypeScript strict mode.

What does production-grade React architecture require for high-reusability components?

Production-grade React requires high-reusability components tested with Jest and Cypress, documented in Storybook, built with TypeScript strict mode, and deployed with optimized bundling. Focus on component isolation, accessibility compliance, comprehensive testing coverage, and integration with React DevTools for debugging and performance monitoring.

When should I refactor existing React code for performance instead of rewriting?

Refactor instead of rewrite when Core Web Vitals lag, component re-renders spike, or bundle size exceeds targets. Analyze with React DevTools and TypeScript strict mode to identify bottlenecks. Apply React.memo, useCallback, code splitting, and state management improvements incrementally while maintaining test coverage with Jest and Cypress.