Skip to main content
skill CX Codex

jotai · jotaijs — Claude Code skill: what it does, how to install

The jotai skill for Claude Code instructs the agent on building, reviewing, and debugging state in React or vanilla TypeScript. It handles atom modeling, store isolation, and async behaviors.

MIT 558 installs ★ 5 updated 2026-10-16

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

What jotai does

The skill enforces architectural invariants for Jotai 3.0.1 and 2.20.x. It guides the AI to maintain stable atom configurations across renders and apply immutable updates. The agent learns to separate state ownership and select the smallest possible change without breaking existing dependency choices.

Instructions route the assistant to specific reference files based on the task. Requests involving server-side rendering or dynamic atom creation trigger reads from references/react-usage.md. If a developer asks to fix subscription performance, the agent consults the large state documentation to apply splitAtom or focusAtom.

The agent must verify the installed Jotai version in the target project before suggesting API changes. The skill strictly separates operations, requiring useAtomValue for reading and useSetAtom for writing to avoid unnecessary reactive subscriptions.

What it helps with

  • model atom boundaries and derived states
  • implement async actions and Suspense flows
  • migrate an existing store from v2 to v3
  • isolate request-owned state during server-side rendering

Example prompts for the agent

  • Refactor this component to use Jotai, separating the write logic into named action atoms.
  • Check the performance of this list render using splitAtom guidelines.
  • Migrate our state setup from Jotai v2 to v3 and update the ESM imports.

How to install jotai

1Skills CLI (Vercel)

npx skills add jotaijs/jotai-skills --skill jotai -a claude-code

2Manually: put the files in place

~/.claude/skills/jotai/SKILL.md

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

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

Questions about jotai

How to install jotai in Claude Code?

Run npx skills add jotaijs/jotai-skills --skill jotai -a claude-code in your terminal.

What does the jotai skill do?

It provides the AI with core invariants and reference routing to write correct Jotai state logic in React.

Which Jotai versions does it cover?

The baseline is Jotai 3.0.1. Specific guidance is included for projects still running 2.20.x.

Source text

SKILL.md · MIT
---
name: jotai
description: Build, review, and debug Jotai state in React or vanilla TypeScript. Use for atom modeling, async state, store isolation and hydration, subscription performance, Jotai utilities and extensions, or v2-to-v3 migration.
---

# Jotai

## Overview

Use Jotai v3 as the baseline for new code. For existing projects, inspect the installed Jotai and extension versions before giving version-sensitive advice. Preserve the requested behavior, architecture, and dependency choices; use refactoring guidance only where it serves the task.

## Workflow

- Identify state ownership, the store used by each reader and writer, atom identity, async behavior, and relevant tests before changing code.
- Choose the smallest change that satisfies the request. Derive computed values, separate independently updated state when useful, and use named action atoms when commands benefit from a shared update path.
- Verify the behavior at the appropriate level: vanilla store tests for state logic and isolation, component tests for subscriptions and user interactions. Match the existing test setup when practical.

## Core Invariants

- Atom configs identify state by reference; values belong to a store. Keep atom configs stable across renders and use the same store for all participants in a state flow.
- Replace object and array values immutably. Jotai uses `Object.is` to detect value changes; mutating a value and setting the same reference can suppress updates.
- Read-function `get` tracks dependencies; write-function `get` reads without establishing a reactive subscription. Keep reads free of unrelated side effects.
- Use `useAtomValue` for reads, `useSetAtom` for writes, and `useAtom` for both. Use vanilla `get`/`set`/`sub` for imperative integrations; a read alone does not mount an atom.
- Keep initialization and subscription lifetimes explicit. `onMount` follows atom subscriptions, not module loading or setter calls. Isolate request-owned state on the server.
- Prefer plain atom composition before utilities. Add utilities or extensions when they encode the required semantics more clearly, checking compatibility with the installed major version.

## Reference Routing

Read only the files that match the task:

- `references/atom-modeling.md` for deciding atom boundaries, derived atoms, action atoms, writable adapters, resets, storage, and family-style parameterized atoms.
- `references/react-usage.md` for hook selection, Provider/store scope, vanilla integrations, SSR, hydration, dynamic atom creation, and component architecture.
- `references/async-and-side-effects.md` for Suspense, async reads, async actions, abort signals, non-Suspense states, refresh flows, and external side effects.
- `references/performance-and-large-state.md` for render tuning, `selectAtom`, `focusAtom`, `splitAtom`, large objects, lists, and dependency graph depth.
- `references/typescript-and-testing.md` for TypeScript inference, writable atom argument types, `ExtractAtomValue`, and testing strategy.
- `references/utilities-decision-guide.md` for choosing built-in utilities such as storage, SSR hydration, resettable/default atoms, lazy atoms, callbacks, reducers, select, split, and family migration.
- `references/extensions-decision-guide.md` for choosing extension packages such as TanStack Query, optics, Immer, effects, location, scope, cache, XState, GraphQL/RPC, and external-store bridges.
- `references/tools-and-debugging.md` for choosing Devtools, Babel, SWC, and Rolldown support for debugging, labels, React Refresh, and bundler integration.
- `references/recipes-decision-guide.md` for deciding when to use or adapt official recipes such as debounce, listeners, broadcast, compare, toggle, custom hooks, reducer hooks, and atom effects.
- `references/version-migration.md` for migrating from v2 to v3: raised React/TypeScript/Node requirements, ESM-only packaging, removed APIs and their replacements, and changes to `jotai/vanilla/internals`.

## Compatibility And Source Verification

This revision was written against Jotai 3.0.1, and covers Jotai 2.20.x where the two differ. Before giving version-sensitive API guidance, determine the target project's installed Jotai and extension-package versions, then inspect their exported types, source, or matching documentation and tests. Do not assume current documentation matches the installed version.

© jotaijs · MIT · jotaijs/jotai-skills

Similar skills

All skills for Frontend and UI →

jotai by other authors comes first.

jotai vercel-labs Wires a Jotai atom as the state backend for json-render's StateStore interface. JSON-described UI components read and write through the atom you provide. CX Codex +1 1,200installs zustand pproenca A skill with 43 rules for Zustand in React: store architecture, selectors, re-render fixes. Useful when you write or refactor a store. CX Codex +1 463installs pinia Anthony Fu A skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that loads Pinia v4.0.3 reference docs into the agent's context. The agent correctly defines stores, applies storeToRefs(), and sets up SSR state hydration. CX Codex +1 20,600installs pinia-skilld skilld-dev pinia-skilld — a skill that feeds your coding agent the correct Pinia 4.x APIs: stores, getters, actions, SSR hydration, testing and v2/v3 migration notes. CX Codex +1 349installs frontend-patterns affaan-m frontend-patterns — a skill for React and Next.js work: component patterns, state, data fetching, and render performance. Use it when building or reviewing UI. CX Codex +1 7,900installs dynamic-import patterns.dev Teaches coding agents on-demand module loading with dynamic import(). It helps cut initial bundle sizes by deferring non-critical components. CX Codex +1 1,700installs zustand-state-management Mindrally zustand-state-management 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 1,000installs

Project sponsors

Companies that keep this analytics open