react-patterns

Document React server, client, presentational, and container component patterns.

Updated Jan 12, 2026
One-click install
npx skills add https://github.com/BenWork17/VeXeViet --skill react-patterns-benwork17
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: react-patterns
Source: https://github.com/BenWork17/VeXeViet/tree/main/.agent/skills/react-patterns
Command: npx skills add https://github.com/BenWork17/VeXeViet --skill react-patterns-benwork17

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Modern React development often suffers from scattered patterns, duplication, and unclear responsibilities across components, making maintenance and scaling difficult.

Core Features & Use Cases

  • Server/Client/Presentational/Container patterns: Guidance on classifying components by role to reduce coupling.
  • Hook Patterns: Best practices for useLocalStorage, useDebounce, useFetch, and custom hooks.
  • Composition & Performance: Techniques for composition, memoization, and avoiding unnecessary renders.

Quick Start

Apply modern React patterns to build robust, maintainable components.

Frequently Asked Questions about react-patterns

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

FAQPage Schema
What are the standard React component patterns for separating concerns?

Standard React component patterns separate concerns by classifying components into server, client, presentational, and container roles to reduce coupling and clarify responsibilities across your application architecture.

How do I structure custom hooks like useLocalStorage and useFetch in React?

Structure custom hooks in React by following consistent usage patterns for useLocalStorage, useDebounce, and useFetch, ensuring clear separation of state logic from rendering concerns for maintainable code.

What's the best way to optimize React performance and avoid unnecessary renders?

Optimize React performance by applying composition and memoization techniques to avoid unnecessary renders, standardizing component design to prevent scattered patterns and duplication across your application.

When do I need to refactor React components into server and client patterns?

Refactor React components into server and client patterns when modern development suffers from scattered architectures, duplication, and unclear responsibilities, making maintenance and scaling across teams difficult.

Does this React component design approach work with TypeScript?

Yes, this React component design approach works with TypeScript, standardizing architecture and component patterns to build robust, maintainable UIs with clear typing and separation of concerns.

Why does my React architecture suffer from unclear component responsibilities?

React architecture suffers from unclear responsibilities when components lack standardized design patterns, leading to coupling, duplication, and maintenance challenges that modern server, client, and container classifications resolve.