Skip to main content
skill CX Codex

vue-development — Claude Code skill: what it does, how to install

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.

MIT 143 installs ★ 114 updated 2026-11-10

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

What vue-development does

This skill injects conventions for Vue 3.4+, TypeScript 5.0+, and Vite 5.0+ into the coding agent. It sets patterns for typed props via defineProps, typed emits, ref and reactive state variables, and watchers.

Included reference guides cover Pinia 2.1+ store definitions, Provide/Inject component patterns, Nuxt 3.10+ data fetching and API routes, and Vitest 1.0+ test suites. A dedicated reference file lists common anti-patterns.

What it helps with

  • build a Vue 3 component using Script Setup and TypeScript
  • set up a Pinia store with state persistence
  • create a reusable composable
  • write component and composable tests using Vitest

Example prompts for the agent

  • Create a counter component with typed props and emits in script setup
  • Build a reusable composable for handling API requests in Nuxt 3
  • Write a Vitest test suite for this Pinia store

How to install vue-development

1Skills CLI (Vercel)

npx skills add travisjneuman/.claude --skill vue-development -a claude-code

2Manually: put the files in place

~/.claude/skills/vue-development/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/vue-development/

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

Questions about vue-development

How to install vue-development in Claude Code?

Run npx skills add travisjneuman/.claude --skill vue-development -a claude-code in the terminal. The files will be placed in ~/.claude/skills/vue-development/SKILL.md.

What does the vue-development skill do?

It provides the agent with conventions for Vue 3 Composition API development, strict TypeScript usage, and Pinia stores. It also includes reference guides for Nuxt 3 and Vitest.

What stack versions does vue-development target?

The skill targets Vue 3.4+, TypeScript 5.0+, Vite 5.0+, Pinia 2.1+, Vue Router 4.2+, Nuxt 3.10+, and Vitest 1.0+.

Source text

SKILL.md · MIT
---
name: vue-development
description: Vue.js 3 development with Composition API, TypeScript, Pinia state management, and Nuxt 3 full-stack. Use when building Vue applications, implementing reactive patterns, creating composables, or working with the Vue ecosystem.
---

# Vue.js 3 Development

Comprehensive guide for building modern Vue.js applications with the Composition API.

## Stack Overview

| Tool       | Purpose              | Version |
| ---------- | -------------------- | ------- |
| Vue 3      | Core framework       | 3.4+    |
| TypeScript | Type safety          | 5.0+    |
| Vite       | Build tool           | 5.0+    |
| Pinia      | State management     | 2.1+    |
| Vue Router | Routing              | 4.2+    |
| Nuxt 3     | Full-stack framework | 3.10+   |
| Vitest     | Testing              | 1.0+    |

---

## Composition API with Script Setup

### Basic Component Structure

```vue
<script setup lang="ts">
import { ref, computed, onMounted } from "vue";

// Props with TypeScript
interface Props {
  title: string;
  count?: number;
}

const props = withDefaults(defineProps<Props>(), {
  count: 0,
});

// Emits with TypeScript
const emit = defineEmits<{
  update: [value: number];
  submit: [];
}>();

// Reactive state
const localCount = ref(props.count);
const items = ref<string[]>([]);

// Computed
const doubleCount = computed(() => localCount.value * 2);

// Methods
function increment() {
  localCount.value++;
  emit("update", localCount.value);
}

// Lifecycle
onMounted(() => {
  console.log("Component mounted");
});
</script>

<template>
  <div class="component">
    <h1>{{ title }}</h1>
    <p>Count: {{ localCount }} (Double: {{ doubleCount }})</p>
    <button @click="increment">Increment</button>
  </div>
</template>

<style scoped>
.component {
  padding: 1rem;
}
</style>
```

### Reactivity Patterns

```typescript
import { ref, reactive, computed, watch, watchEffect } from "vue";

// Primitives: use ref()
const count = ref(0);
const name = ref("");
count.value++; // Access via .value

// Objects/Arrays: use reactive()
const state = reactive({
  items: [] as Item[],
  loading: false,
  error: null as Error | null,
});
state.items.push(item); // Direct access, no .value

// Computed values
const total = computed(() => state.items.reduce((sum, i) => sum + i.price, 0));

// Watch specific values
watch(count, (newVal, oldVal) => {
  console.log(`Count changed: ${oldVal} -> ${newVal}`);
});

// Watch with options
watch(
  () => state.items,
  (newItems) => saveToStorage(newItems),
  { deep: true, immediate: true },
);

// Automatic dependency tracking
watchEffect(() => {
  console.log(`Count is now: ${count.value}`);
});
```

---

## Reference files

Detailed material is in separate files so this overview stays short. Read only the file whose topic matches the task; each one is self-contained. Paths are relative to the folder that holds this `SKILL.md` (in the full toolkit install, `~/.claude/skills/vue-development/`).

| Topic | File | Covers |
| --- | --- | --- |
| Composables (Reusable Logic) | [`references/composables-reusable-logic.md`](references/composables-reusable-logic.md) | Naming & Structure; Creating Composables; Composable Best Practices |
| Pinia State Management | [`references/pinia-state-management.md`](references/pinia-state-management.md) | Store Definition (Composition Style); Using Stores in Components; Store with Persistence |
| Component Patterns | [`references/component-patterns.md`](references/component-patterns.md) | Provider/Inject Pattern; Smart/Dumb Components |
| Nuxt 3 (Full-Stack) | [`references/nuxt-3-full-stack.md`](references/nuxt-3-full-stack.md) | Project Structure; API Routes; Data Fetching |
| Testing with Vitest | [`references/testing-with-vitest.md`](references/testing-with-vitest.md) | Setup; Component Testing; Composable Testing |
| Anti-Patterns to Avoid | [`references/anti-patterns-to-avoid.md`](references/anti-patterns-to-avoid.md) | 13 lines |

## Related Resources

- [Vue.js Official Docs](https://vuejs.org/)
- [Pinia Documentation](https://pinia.vuejs.org/)
- [Nuxt 3 Documentation](https://nuxt.com/)
- [VueUse Composables](https://vueuse.org/)
- [Vue Test Utils](https://test-utils.vuejs.org/)

---

## When to Use This Skill

- Building new Vue.js 3 applications
- Migrating from Vue 2 Options API to Composition API
- Implementing Pinia state management
- Creating reusable composables
- Full-stack development with Nuxt 3
- Testing Vue components with Vitest

© travisjneuman · MIT · travisjneuman/.claude

Similar skills

All skills for Frontend and UI →

From the same set117

The whole set →
generic-ux-designer generic-ux-designer — a UX skill for Claude and other coding agents: design-thinking steps, heuristic review and accessibility checks, packaged as checklists the agent follows. CX Codex +1 145installs performance-engineering performance-engineering — a skill for Claude Code designed for full-stack web application performance optimization. Activates when Core Web Vitals drop, bundle sizes increase, or page response times degrade. CX Codex +1 144installs authentication-patterns authentication-patterns — a Claude Code skill for authentication and authorization patterns. It comes into play when building login flows, MFA, SSO, or access-control models. CX Codex +1 144installs i18n-localization The i18n-localization Claude Code skill guides internationalization and localization work. It activates for translation setup, locale-specific formatting, and adapting an app for multiple regions. CX Codex +1 143installs generic-design-system generic-design-system provides standard design system guidelines for AI coding agents, covering color tokens, typography, spacing scales, and component states. CX Codex +1 143installs event-driven-architecture The event-driven-architecture skill guides asynchronous system design around brokers, event flows, and distributed work. Use it when services must communicate through messages. CX Codex +1 143installs content-repurposer content-repurposer turns one piece of writing into a thread, a LinkedIn post, a carousel or a newsletter, and shifts the tone to match the channel. CX Codex +1 142installs generic-feature-developer generic-feature-developer walks a feature from reading the codebase to picking patterns, shipping small commits and checking edge cases before you close it. CX Codex +1 142installs

Project sponsors

Companies that keep this analytics open