Skip to main content
skill CX Codex

zustand · pproenca — Claude Code skill: Zustand patterns for React

A skill with 43 rules for Zustand in React: store architecture, selectors, re-render fixes. Useful when you write or refactor a store.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add pproenca/dot-skills --skill zustand -a claude-code
Open on GitHub

What zustand does

The skill hands your agent a Zustand reference: 43 rules in 8 categories, ordered by impact. Store architecture and selector optimization come first, then re-render prevention, state updates, middleware, SSR and hydration, TypeScript patterns, advanced cases. Each rule lives in its own file under references/ with an explanation and code samples.

The agent pulls it in when you create a store, chase extra re-renders, wire up persist or immer, or connect Zustand to Next.js. The recipes are concrete: several small stores instead of one big one, actions kept apart from state, useShallow for multi-field picks, partialize for selective persistence, skipHydration under SSR.

Worth installing if Zustand is already in your project and you would rather not have the agent subscribe components to the whole store. The skill does not replace the library, it only describes how to use it.

What it helps with

  • split a monolithic store into feature-scoped ones
  • cut re-renders with atomic selectors
  • persist only part of the state to localStorage
  • fix hydration mismatch with Zustand under SSR
  • type slices with StateCreator

Example prompts for the agent

  • create the cart store following the zustand skill rules
  • the component re-renders on every store update — check the selectors
  • add persist with partialize to the settings store

How to install zustand

1Skills CLI (Vercel)

npx skills add pproenca/dot-skills --skill zustand -a claude-code

2Manually: put the files in place

~/.claude/skills/zustand/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/zustand/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about zustand

How do I install zustand in Claude?

Run npx skills add pproenca/dot-skills --skill zustand -a claude-code. The skill lands in ~/.claude/skills/zustand/SKILL.md.

What does the zustand skill do?

It gives the agent 43 Zustand rules for React: store architecture, selectors, re-renders, middleware, SSR, types. The agent checks them while writing or refactoring a store.

Which platforms are supported?

Claude, Codex, Cursor, GitHub Copilot, Gemini CLI and OpenCode. Only the -a flag changes between them.

Source text

SKILL.md · MIT
---
name: zustand
description: Zustand state management best practices for React applications. Use when writing, reviewing, or refactoring Zustand stores to ensure optimal performance and maintainability. Triggers on tasks involving state management, stores, selectors, re-renders, and Zustand patterns.
---

# Community Zustand Best Practices

Comprehensive performance and architecture guide for Zustand state management in React applications. Contains 43 rules across 8 categories, prioritized by impact from critical (store architecture, selector optimization) to incremental (advanced patterns).

## When to Apply

Reference these guidelines when:
- Creating new Zustand stores
- Optimizing re-render performance with selectors
- Implementing persistence or middleware
- Integrating Zustand with SSR/Next.js
- Reviewing code for state management patterns

## Rule Categories by Priority

| Priority | Category | Impact | Prefix |
|----------|----------|--------|--------|
| 1 | Store Architecture | CRITICAL | `store-` |
| 2 | Selector Optimization | CRITICAL | `select-` |
| 3 | Re-render Prevention | HIGH | `render-` |
| 4 | State Updates | MEDIUM-HIGH | `update-` |
| 5 | Middleware Configuration | MEDIUM | `mw-` |
| 6 | SSR and Hydration | MEDIUM | `ssr-` |
| 7 | TypeScript Patterns | LOW-MEDIUM | `ts-` |
| 8 | Advanced Patterns | LOW | `adv-` |

## Quick Reference

### 1. Store Architecture (CRITICAL)

- [`store-multiple-stores`](references/store-multiple-stores.md) - Use multiple small stores instead of one monolithic store
- [`store-separate-actions`](references/store-separate-actions.md) - Separate actions from state in dedicated namespace
- [`store-event-naming`](references/store-event-naming.md) - Name actions as events not setters
- [`store-colocate-logic`](references/store-colocate-logic.md) - Colocate actions with the state they modify
- [`store-avoid-derived-state`](references/store-avoid-derived-state.md) - Derive computed values instead of storing them
- [`store-domain-boundaries`](references/store-domain-boundaries.md) - Organize stores by feature domain

### 2. Selector Optimization (CRITICAL)

- [`select-always-use`](references/select-always-use.md) - Always use selectors never subscribe to entire store
- [`select-atomic-picks`](references/select-atomic-picks.md) - Use atomic selectors for single values
- [`select-stable-returns`](references/select-stable-returns.md) - Ensure selectors return stable references
- [`select-custom-hooks`](references/select-custom-hooks.md) - Export custom hooks not raw store
- [`select-auto-generate`](references/select-auto-generate.md) - Use auto-generated selectors for large stores
- [`select-memoize-computed`](references/select-memoize-computed.md) - Memoize expensive computed selectors
- [`select-avoid-inline`](references/select-avoid-inline.md) - Define selectors outside components

### 3. Re-render Prevention (HIGH)

- [`render-use-shallow`](references/render-use-shallow.md) - Use useShallow for multi-property selections
- [`render-equality-fn`](references/render-equality-fn.md) - Provide custom equality functions when needed
- [`render-memo-children`](references/render-memo-children.md) - Memo children affected by parent store updates
- [`render-subscribe-external`](references/render-subscribe-external.md) - Use subscribe for non-React consumers
- [`render-avoid-object-returns`](references/render-avoid-object-returns.md) - Avoid returning new objects from selectors
- [`render-split-components`](references/render-split-components.md) - Split components to minimize subscription scope

### 4. State Updates (MEDIUM-HIGH)

- [`update-functional-set`](references/update-functional-set.md) - Use functional form when updating based on previous state
- [`update-immutable`](references/update-immutable.md) - Never mutate state directly
- [`update-shallow-merge`](references/update-shallow-merge.md) - Understand set() shallow merge behavior
- [`update-async-actions`](references/update-async-actions.md) - Handle async actions with loading and error states
- [`update-batch-updates`](references/update-batch-updates.md) - Batch related updates in single set call

### 5. Middleware Configuration (MEDIUM)

- [`mw-devtools-actions`](references/mw-devtools-actions.md) - Name actions for DevTools debugging
- [`mw-persist-partialize`](references/mw-persist-partialize.md) - Use partialize for selective persistence
- [`mw-persist-migration`](references/mw-persist-migration.md) - Version and migrate persisted state
- [`mw-immer-nested`](references/mw-immer-nested.md) - Use immer for deeply nested state updates
- [`mw-combine-order`](references/mw-combine-order.md) - Apply middlewares in correct order
- [`mw-slice-middleware`](references/mw-slice-middleware.md) - Apply middleware at combined store level

### 6. SSR and Hydration (MEDIUM)

- [`ssr-skip-hydration`](references/ssr-skip-hydration.md) - Use skipHydration in SSR contexts
- [`ssr-manual-rehydrate`](references/ssr-manual-rehydrate.md) - Manually rehydrate on client mount
- [`ssr-hydration-hook`](references/ssr-hydration-hook.md) - Use custom hook to prevent hydration mismatch
- [`ssr-check-window`](references/ssr-check-window.md) - Guard browser APIs with typeof window check

### 7. TypeScript Patterns (LOW-MEDIUM)

- [`ts-state-creator`](references/ts-state-creator.md) - Use StateCreator for slice typing
- [`ts-middleware-inference`](references/ts-middleware-inference.md) - Preserve type inference with middleware
- [`ts-separate-types`](references/ts-separate-types.md) - Separate state and actions interfaces
- [`ts-generic-selectors`](references/ts-generic-selectors.md) - Type selectors for reusability
- [`ts-bound-store`](references/ts-bound-store.md) - Type combined stores correctly

### 8. Advanced Patterns (LOW)

- [`adv-context-stores`](references/adv-context-stores.md) - Combine Zustand with React Context for dependency injection
- [`adv-transient-updates`](references/adv-transient-updates.md) - Use subscribe for transient updates
- [`adv-computed-getters`](references/adv-computed-getters.md) - Implement computed state with getters
- [`adv-third-party-integration`](references/adv-third-party-integration.md) - Integrate with React Query and SWR

## How to Use

Read individual reference files for detailed explanations and code examples:

- [Section definitions](references/_sections.md) - Category structure and impact levels
- [Rule template](assets/templates/_template.md) - Template for adding new rules

## Reference Files

| File | Description |
|------|-------------|
| [references/_sections.md](references/_sections.md) | Category definitions and ordering |
| [assets/templates/_template.md](assets/templates/_template.md) | Template for new rules |
| [metadata.json](metadata.json) | Version and reference information |

© pproenca · MIT · pproenca/dot-skills

Similar skills

Everything for Frontend and UI →

zustand by other authors comes first.

zustand vercel-labs This skill integrates Zustand into json-render to sync application state. Use it when your project already relies on Zustand and you need to connect it with components rendered by json-render. CX Codex +1 1,900installs zustand pedronauck A skill that feeds your coding agent Zustand patterns: domain stores, selector hooks, middleware and persistence. CX Codex +1 353installs zustand bobmatnyc A skill that teaches your agent zustand: a small hook-based state manager for React with no providers. Handy when you need global state but not Redux. CX Codex +1 485installs zustand-state-management Mindrally Enforces Zustand store best practices in React and TypeScript apps, covering store slices, SSR, and testing. It helps eliminate selector re-renders and hydration bugs. CX Codex +1 959installs zustand-patterns OrchestKit A reference for Zustand 5.x state management: slices, middleware, Immer, useShallow, persistence and devtools. Useful when you want to drop Redux without the boilerplate. CX Codex +1 1,400installs zustand-5 prowler-cloud Zustand 5 state management patterns for Claude Code: basic stores, selectors, persist middleware, and slice composition. Prevents unnecessary re-renders and keeps state logic clean. CX Codex +1 911installs zustand-store-ts Microsoft A skill that sets the pattern for Zustand stores in TypeScript: separate state and action types, subscribeWithSelector, individual selectors. 3installs state-management agent-skills A skill that hands your agent ready patterns for TanStack Query v5 and Zustand v5: fetching, caching, mutations, optimistic updates and client stores. CX Codex +1 783installs frontend-state-management aj-geddes A skill that guides your agent through frontend state management: Redux, MobX, Zustand or the Context API. CX Codex +1 480installs

From the same set45

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor