playbooks

home / skills / sickn33 / antigravity-awesome-skills / react-patterns

react-patterns skill

/skills/react-patterns

This skill helps you apply modern React patterns and TypeScript best practices to build scalable, performant components with clean architecture.

This is most likely a fork of the react-patterns skill from xfstudio
npx playbooks add skill sickn33/antigravity-awesome-skills --skill react-patterns

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.7 KB
---
name: react-patterns
description: Modern React patterns and principles. Hooks, composition, performance, TypeScript best practices.
allowed-tools: Read, Write, Edit, Glob, Grep
---

# React Patterns

> Principles for building production-ready React applications.

---

## 1. Component Design Principles

### Component Types

| Type | Use | State |
|------|-----|-------|
| **Server** | Data fetching, static | None |
| **Client** | Interactivity | useState, effects |
| **Presentational** | UI display | Props only |
| **Container** | Logic/state | Heavy state |

### Design Rules

- One responsibility per component
- Props down, events up
- Composition over inheritance
- Prefer small, focused components

---

## 2. Hook Patterns

### When to Extract Hooks

| Pattern | Extract When |
|---------|-------------|
| **useLocalStorage** | Same storage logic needed |
| **useDebounce** | Multiple debounced values |
| **useFetch** | Repeated fetch patterns |
| **useForm** | Complex form state |

### Hook Rules

- Hooks at top level only
- Same order every render
- Custom hooks start with "use"
- Clean up effects on unmount

---

## 3. State Management Selection

| Complexity | Solution |
|------------|----------|
| Simple | useState, useReducer |
| Shared local | Context |
| Server state | React Query, SWR |
| Complex global | Zustand, Redux Toolkit |

### State Placement

| Scope | Where |
|-------|-------|
| Single component | useState |
| Parent-child | Lift state up |
| Subtree | Context |
| App-wide | Global store |

---

## 4. React 19 Patterns

### New Hooks

| Hook | Purpose |
|------|---------|
| **useActionState** | Form submission state |
| **useOptimistic** | Optimistic UI updates |
| **use** | Read resources in render |

### Compiler Benefits

- Automatic memoization
- Less manual useMemo/useCallback
- Focus on pure components

---

## 5. Composition Patterns

### Compound Components

- Parent provides context
- Children consume context
- Flexible slot-based composition
- Example: Tabs, Accordion, Dropdown

### Render Props vs Hooks

| Use Case | Prefer |
|----------|--------|
| Reusable logic | Custom hook |
| Render flexibility | Render props |
| Cross-cutting | Higher-order component |

---

## 6. Performance Principles

### When to Optimize

| Signal | Action |
|--------|--------|
| Slow renders | Profile first |
| Large lists | Virtualize |
| Expensive calc | useMemo |
| Stable callbacks | useCallback |

### Optimization Order

1. Check if actually slow
2. Profile with DevTools
3. Identify bottleneck
4. Apply targeted fix

---

## 7. Error Handling

### Error Boundary Usage

| Scope | Placement |
|-------|-----------|
| App-wide | Root level |
| Feature | Route/feature level |
| Component | Around risky component |

### Error Recovery

- Show fallback UI
- Log error
- Offer retry option
- Preserve user data

---

## 8. TypeScript Patterns

### Props Typing

| Pattern | Use |
|---------|-----|
| Interface | Component props |
| Type | Unions, complex |
| Generic | Reusable components |

### Common Types

| Need | Type |
|------|------|
| Children | ReactNode |
| Event handler | MouseEventHandler |
| Ref | RefObject<Element> |

---

## 9. Testing Principles

| Level | Focus |
|-------|-------|
| Unit | Pure functions, hooks |
| Integration | Component behavior |
| E2E | User flows |

### Test Priorities

- User-visible behavior
- Edge cases
- Error states
- Accessibility

---

## 10. Anti-Patterns

| ❌ Don't | ✅ Do |
|----------|-------|
| Prop drilling deep | Use context |
| Giant components | Split smaller |
| useEffect for everything | Server components |
| Premature optimization | Profile first |
| Index as key | Stable unique ID |

---

> **Remember:** React is about composition. Build small, combine thoughtfully.

Overview

This skill packages a concise collection of modern React patterns and principles for building production-ready applications. It focuses on component design, hooks, state management, performance, TypeScript, testing, and error handling. The guidance is practical, opinionated, and aligned with React 18/19 capabilities.

How this skill works

The skill inspects common architectural decisions and recommends patterns based on scope and complexity: when to use server vs client components, when to extract hooks, and which state solution fits a need. It highlights composition techniques, performance triage, TypeScript typing conventions, testing priorities, and anti-patterns to avoid. The output is actionable rules and checklists you can apply directly to components, hooks, and feature boundaries.

When to use it

  • Scaffolding a new React feature or deciding component boundaries.
  • Refactoring an app to improve performance or reduce complexity.
  • Choosing a state management approach for local, shared, or global state.
  • Introducing TypeScript typings for reusable components and hooks.
  • Designing error boundaries and recovery flows for production apps.

Best practices

  • Design components with a single responsibility; prefer small, focused components.
  • Keep hooks at the top level, name custom hooks with "use", and clean up effects.
  • Lift state up for parent-child communication and use Context for subtree sharing.
  • Profile first before optimizing; virtualize large lists and memoize only when needed.
  • Type props with interfaces, use generics for reusable components, and use ReactNode for children.
  • Place error boundaries at root or feature routes and surface clear fallback and retry actions.

Example use cases

  • Create a compound Tabs component where the parent provides context and children consume it for slot-based composition.
  • Extract a useDebounce hook shared across multiple inputs to centralize timing logic and cleanup.
  • Migrate server-side data fetching into server components while keeping interactivity in client components.
  • Choose React Query for server state, Context for subtree state, and Zustand for complex global state in a performant app.
  • Add targeted performance fixes: profile slow renders, memoize expensive calculations, and virtualize long lists.

FAQ

When should I extract a custom hook?

Extract a hook when the logic is reused across components or when it simplifies component code, for example cross-cutting fetch, debounce, or form state.

How do I decide between Context and a global store?

Use Context for sharing state within a subtree and when updates are localized; use a global store (Zustand/Redux Toolkit) for high-frequency updates or app-wide state.