Skip to main content
skill CX Codex

state-management · patternsdev — Claude Code skill: what it does, how to install

Guides the coding agent through Vue 3 state management patterns. Helps decide between props, simple reactive() stores, and Pinia.

MIT 201 installs ★ 259 updated 2026-04-15

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

What state-management does

The skill applies when an assistant works on **/*.vue files. It clarifies when parent-child props and custom events are no longer sufficient to coordinate state. For sibling or deeply nested components, it demonstrates how to elevate reactive data into application-level state.

Architectural guidance depends on application complexity. For simple tasks, the skill instructs the model to build a lightweight store using Vue's reactive() function. It reserves Pinia for larger codebases that need devtools integration, plugins, or TypeScript support.

Over-engineering smaller apps is a mistake. The skill explicitly keeps the agent from dropping full Pinia setups into projects that only need a plain Composition API store.

What it helps with

  • share reactive state between sibling components in Vue 3
  • replace deep prop drilling with a shared reactive() store
  • dispatch custom events from child components to parents
  • set up Pinia stores with defineStore for larger applications

Example prompts for the agent

  • Create a shared reactive() store to sync counter values across two sibling components
  • Refactor this component tree to send user actions upward using custom events
  • Set up a Pinia store with defineStore to manage global user session state

How to install state-management

1Skills CLI (Vercel)

npx skills add PatternsDev/skills --skill state-management -a claude-code

2Manually: put the files in place

~/.claude/skills/state-management/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/state-management/

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

Questions about state-management

How to install state-management in Claude Code?

Run npx skills add PatternsDev/skills --skill state-management -a claude-code. The skill file will be placed in ~/.claude/skills/state-management/SKILL.md.

What does the state-management skill do?

It instructs your AI assistant on Vue 3 data flow conventions. It directs the model toward props, lightweight reactive() stores, or Pinia based on project scale.

When does this skill recommend Pinia over a simple store?

The guide specifies Pinia for larger applications that benefit from TypeScript support, devtools, and plugin architecture.

Source text

SKILL.md · MIT
---
name: state-management
description: Teaches Vue state management with stores, Pinia, and the Composition API. Use when you need to share and synchronize state across multiple components beyond what props and events can handle.
paths:
  - "**/*.vue"
license: MIT
metadata:
  author: patterns.dev
  version: "1.1"
related_skills:
  - "composables"
  - "components"
---

# State Management

## Table of Contents

- [When to Use](#when-to-use)
- [Instructions](#instructions)
- [Details](#details)
- [Source](#source)

**Vue components are the building blocks of Vue apps** by allowing us to couple markup (HTML), logic (JS), and styles (CSS) within them.

## When to Use

- Use this when you need to share reactive data between sibling or deeply nested components
- This is helpful for managing global application state beyond simple parent-child prop passing

## Instructions

- Use props for parent-to-child data flow and custom events for child-to-parent communication
- Create a simple store using `reactive()` for small applications
- Use Pinia (the official Vue state management library) for larger apps needing devtools, plugins, and TypeScript support
- Choose the state management approach based on your app's complexity — don't over-engineer small apps

## Details

Here's an example of a Single-File component that displays a series of numbers from a data property:

```html
<template>
  <div>
    <h2>The numbers are {{ numbers }}!</h2>
  </div>
</template>

<script setup>
  import { ref } from "vue";

  const numbers = ref([1, 2, 3]);
</script>
```

The `ref()` function prepares the component to be _reactive_. If a reactive property value that's being used in the template changes, the component view will re-render to show the change.

What if `numbers` was a data value that needed to be accessed from another component? If we want to share `numbers` between multiple components, `numbers` doesn't only become component-level data _but also_ application-level data. This brings us to the topic of **State Management** - the management of application level data.

### Props

Vue gives us the ability to use **props** to pass data from the parent down to the child. Using props is fairly simple. All we essentially need to do is bind a value to the prop attribute where the child component is being rendered.

**ParentComponent**:

```html
<template>
  <div>
    <ChildComponent :numbers="numbers" />
  </div>
</template>

<script setup>
  import { ref } from "vue";
  import ChildComponent from "./ChildComponent";

  const numbers = ref([1, 2, 3]);
</script>
```

**ChildComponent**:

```html
<template>
  <div>
    <h2>{{ numbers }}</h2>
  </div>
</template>

<script setup>
  const { numbers } = defineProps(["numbers"]);
</script>
```

### Component Events

What if we needed to find a way to communicate information in the opposite direction? We can't use `props` since `props` can only be used to pass data in a uni-directional format (from parent down to child). To facilitate having the child component notify the parent about something, we can use custom events.

Custom events in Vue are dispatched as native CustomEvents and are used for communication between components.

**ChildComponent**:

```html
<template>
  <div>
    <h2>{{ numbers }}</h2>
    <input v-model="number" type="number" />
    <button @click="$emit('number-added', Number(number))">
      Add new number
    </button>
  </div>
</template>

<script setup>
  const { numbers } = defineProps(["numbers"]);
</script>
```

**ParentComponent**:

```html
<template>
  <div>
    <ChildComponent :numbers="numbers" @number-added="(n) => numbers.push(n)" />
  </div>
</template>

<script setup>
  import { ref } from "vue";
  import ChildComponent from "./ChildComponent";

  const numbers = ref([1, 2, 3]);
</script>
```

### Simple State Management

We can use props to pass data downwards and custom events to send messages upwards. How would we be able to either pass data or facilitate communication between two different sibling components?

A simple way to manage application-level state is to create a store pattern that involves sharing a data store between components. The store can manage the state of our application as well as the methods that are responsible for changing the state.

```js
import { reactive } from "vue";

export const store = reactive({
  numbers: [1, 2, 3],
  addNumber(newNumber) {
    this.numbers.push(newNumber);
  },
});
```

The store contains a `numbers` array and an `addNumber` method that accepts a payload and directly updates the store's `numbers` value.

With Vue 3.x, we're able to import and use the `reactive()` function to declare reactive state from a JavaScript object. When this reactive state gets changed with the `addNumber()` method, any component that uses this reactive state will automatically update!

**NumberDisplay**:

```html
<template>
  <div>
    <h2>{{ store.numbers }}</h2>
  </div>
</template>

<script setup>
  import { store } from "../store.js";
</script>
```

**NumberSubmit**:

```html
<template>
  <div>
    <input v-model="numberInput" type="number" />
    <button @click="store.addNumber(numberInput)">Add new number</button>
  </div>
</template>

<script setup>
  import { ref } from "vue";
  import { store } from "../store.js";

  const numberInput = ref(0);
</script>
```

When we say components interact with one another here, we're using the term 'interact' loosely. The components aren't going to do anything to each other but instead invoke changes to one another _through_ the store.

If we take a closer look at all the pieces that directly interact with the store, we can establish a pattern:

- The method in `NumberSubmit` has the responsibility to directly act on the store method, so we can label it as a **store action**.
- The store method has a certain responsibility as well - to directly mutate the store state. So we'll say it's a **store mutation**.
- `NumberDisplay` doesn't really care about what type of methods exist in the store or in `NumberSubmit`, and is only concerned with getting information from the store. So we'll say `NumberDisplay` is a **store getter** of sorts.

An **action** commits to a **mutation**. The **mutation** mutates state which then affects the view/components. View/components retrieve store data with **getters**. We're starting to get closer to a more structured manner to handling application-level state.

### Pinia

[Pinia](https://pinia.vuejs.org/) is a state management pattern and library for Vue.js that provides a more structured and scalable way to handle application-level state.

Pinia is an alternative to other state management solutions like [Vuex](https://vuex.vuejs.org/) and is now the official state management library for Vue. It provides a simple and efficient way to create and manage stores, which encapsulate state, actions, and getters.

In Pinia, we can define a store using the `defineStore()` function. Here we're using the Composition API syntax to define a `useNumbersStore()` function to create a `numbers` store.

```js
import { ref } from "vue";
import { defineStore } from "pinia";

export const useNumbersStore = defineStore("numbers", () => {
  const numbers = ref([1, 2, 3]);

  function addNumber(newNumber) {
    numbers.value.push(newNumber);
  }

  return { numbers, addNumber };
});
```

We can then create a Pinia instance and install it in our Vue app.

```js
import { createApp } from "vue";
import { createPinia } from "pinia";
import App from "./App.vue";

const app = createApp(App);
const pinia = createPinia();

app.use(pinia);
app.mount("#app");
```

In the `NumberDisplay` component:

```html
<template>
  <div>
    <h2>{{ store.numbers }}</h2>
  </div>
</template>

<script setup>
  import { useNumbersStore } from "../store";

  const store = useNumbersStore();
</script>
```

In the `NumberSubmit` component:

```html
<template>
  <div>
    <input v-model="numberInput" type="number" />
    <button @click="store.addNumber(numberInput)">Add new number</button>
  </div>
</template>

<script setup>
  import { ref } from "vue";
  import { useNumbersStore } from "../store";

  const store = useNumbersStore();
  const numberInput = ref(0);
</script>
```

For such a simple implementation like this, a Pinia store may not really be necessary and behaves very similarly to just using a store created with the `reactive()` function. With that said, Pinia offers additional capabilities for more complex use-cases such as the ability to extend Pinia features with plugins, have devtools support, and have more appropriate TypeScript support and server-side rendering support.

### What's the correct way?

Each method for managing application-level state comes with its advantages and disadvantages.

#### Simple Store

- **Pro**: Relatively easy to establish.
- **Con**: State and possible state changes aren't explicitly defined.

#### Pinia

- **Pro**: Devtools support, plugins + typescript + server-side rendering support
- **Con**: Additional boilerplate.

At the end of the day, it's up to us to understand what's needed in our application and what the best approach may be.

## Source

- [patterns.dev/vue/state-management](https://patterns.dev/vue/state-management)

### References

- [Props | Vue Documentation](https://vuejs.org/guide/components/props.html#props)
- [Component Events | Vue Documentation](https://vuejs.org/guide/components/events.html#component-events)
- [Simple State Management with Reactivity API | Vue Documentation](https://vuejs.org/guide/scaling-up/state-management.html#simple-state-management-with-reactivity-api)
- [Core concepts | Pinia](https://pinia.vuejs.org/core-concepts/)

© patterns.dev · MIT · PatternsDev/skills

Similar skills

All skills for Frontend and UI →

state-management by other authors comes first.

state-management agent-skills state-management is a Claude Code skill for handling data fetching, caching, and client-side state with React Query and Zustand. It activates around useQuery, useMutation, Zustand stores, and state-management tasks. CX Codex +1 849installs state-management statelyai state-management is a Claude Code skill that models application state before library selection. It reviews and refactors models, keeps source state minimal, computes derived values, and makes invalid states hard to represent. CX Codex +1 181installs state-management akillness state-management — a skill that classifies React state into packets and picks the narrowest owner, so you stop arguing about libraries before you know what the state is. CX Codex +1 367installs vue-expert https://github.com/Jeffallan vue-expert guides Vue 3 work with the Composition API, Nuxt 3, Pinia, and Vite. Use it for components, PWAs, and Quasar or Capacitor apps. CX Codex +1 4,800installs vue-development travisjneuman vue-development — a Claude Code skill for building Vue 3 applications with the Composition API and Script Setup. Guides state setup in Pinia, custom composables, and Nuxt 3 full-stack tasks. CX Codex +1 143installs vue official github A GitHub Copilot rule that encodes Vue 3 development standards. Drop the instructions file into a repo and Copilot follows the same patterns for components, reactivity, Pinia and TypeScript. CX Codex +1 ★ 41,430repo stars Expert Vue.js Frontend Engineer official github Expert Vue.js Frontend Engineer — a GitHub Copilot subagent for building Vue 3 frontends with TypeScript. It handles components, Pinia stores, tests and rendering performance as part of your coding session. CX Codex +1 ★ 41,430repo stars 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 vue-pinia-best-practices github.com/vuejs-ai vue-pinia-best-practices — a skill covering Pinia best practices: avoid common store setup errors, preserve reactivity, and organize state management patterns in Vue projects. CX Codex +1 18,500installs

From the same set58

The whole set →
composables Teaches the agent to write Vue composables — reusable stateful logic with the Composition API. Use it when reactive state, computed properties or side effects are shared across components. CX Codex +1 211installs async-components Teaches the agent to load Vue components asynchronously via defineAsyncComponent(), so heavy modals and dialogs don't ship with the initial bundle. CX Codex +1 207installs container-presentational Teaches the container/presentational pattern for Vue components: containers fetch data, presentational components render it via props without touching state. CX Codex +1 205installs data-provider Explains Vue’s data provider pattern for moving fetch and state logic into a renderless component with scoped slot props. CX Codex +1 204installs dynamic-components dynamic-components teaches switching Vue components at runtime through the reserved <component> element and its is attribute. Handy for tabbed views that don't need a router. CX Codex +1 198installs provide-inject provide-inject teaches the agent Vue's provide() and inject() API for passing data to deeply nested components without threading props through every level. CX Codex +1 196installs render-functions render-functions teaches your AI assistant to build dynamic Vue components using the h() render function and JSX. Useful for component libraries when standard templates become too restrictive. CX Codex +1 196installs script-setup Teaches the agent to write Vue 3 components with <script setup> — no boilerplate, no explicit return. CX Codex +1 195installs

Project sponsors

Companies that keep this analytics open