Skip to main content
rule CX Codex

nuxtjs-vue-typescript-development-rules — Claude Code rule

nuxtjs-vue-typescript-development-rules defines Nuxt 3, Vue 3, and TypeScript development guidelines for Claude Code, focusing on Composition API, Tailwind, and Pinia.

MIT ★ 571 updated 2026-07-03

Install into Claude Code · Manually: put the files in place All methods and platforms ↓
.claude/rules/NuxtJS-Vue-TypeScript-Development-Rules.md
Open on GitHub

What nuxtjs-vue-typescript-development-rules does

This rule configures Claude Code to write code tailored for Nuxt 3, Vue 3, TypeScript, Pinia, VueUse, and Tailwind CSS. The assistant relies on Composition API with <script setup>, skipping Options API entirely. UI styling builds around Shadcn Vue and Radix Vue with a mobile-first responsive approach.

Standard TypeScript enums are banned in favor of const objects, and type declarations take priority over interfaces. Code files follow a strict internal hierarchy: exported components, composables, helpers, static content, and types. Network requests use Nuxt built-ins like useFetch and useAsyncData.

Naming conventions stay consistent throughout the codebase. Folders use kebab-case, components use PascalCase, and composables require camelCase.

What it helps with

  • Enforce Nuxt 3 and Vue 3 Composition API conventions in generated code
  • Standardize folder, component, and composable naming patterns
  • Handle state management and data fetching via Pinia and useFetch
  • Implement responsive UI elements with Tailwind CSS and Shadcn Vue

Example prompts for the agent

  • Create an AuthWizard.vue component using <script setup>, Tailwind CSS, and Shadcn Vue.
  • Write a useAuthState.ts composable managing user session state with Pinia.
  • Set up a dynamic page fetching items via useFetch with SEO meta tags configured.

How to install nuxtjs-vue-typescript-development-rules

Manually: put the files in place

.claude/rules/NuxtJS-Vue-TypeScript-Development-Rules.md

The paths frontmatter field limits the files

Step by step, with commands for each platform: AGENTS.md vs CLAUDE.md: what they are and which one to use

Questions about nuxtjs-vue-typescript-development-rules

How to install nuxtjs-vue-typescript-development-rules in Claude Code?

Place the rule file at .claude/rules/NuxtJS-Vue-TypeScript-Development-Rules.md inside your project directory.

What does nuxtjs-vue-typescript-development-rules do?

It guides Claude Code to output Nuxt 3 code utilizing <script setup>, type aliases instead of enums, Pinia for store state, and Tailwind CSS.

Which TypeScript practices does this rule require?

The rule prohibits TypeScript enums in favor of const objects and prefers type aliases over interfaces.

Source text

NuxtJS-Vue-TypeScript-Development-Rules.md · MIT
# NuxtJS Vue TypeScript Development Rules

```json
You are an expert in TypeScript, Node.js, NuxtJS, Vue 3, Shadcn Vue, Radix Vue, VueUse, and Tailwind.

      Code Style and Structure
      - Write concise, technical TypeScript code with accurate examples.
      - Use composition API and declarative programming patterns; avoid options API.
      - Prefer iteration and modularization over code duplication.
      - Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).
      - Structure files: exported component, composables, helpers, static content, types.

      Naming Conventions
      - Use lowercase with dashes for directories (e.g., components/auth-wizard).
      - Use PascalCase for component names (e.g., AuthWizard.vue).
      - Use camelCase for composables (e.g., useAuthState.ts).

      TypeScript Usage
      - Use TypeScript for all code; prefer types over interfaces.
      - Avoid enums; use const objects instead.
      - Use Vue 3 with TypeScript, leveraging defineComponent and PropType.

      Syntax and Formatting
      - Use arrow functions for methods and computed properties.
      - Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements.
      - Use template syntax for declarative rendering.

      UI and Styling
      - Use Shadcn Vue, Radix Vue, and Tailwind for components and styling.
      - Implement responsive design with Tailwind CSS; use a mobile-first approach.

      Performance Optimization
      - Leverage Nuxt's built-in performance optimizations.
      - Use Suspense for asynchronous components.
      - Implement lazy loading for routes and components.
      - Optimize images: use WebP format, include size data, implement lazy loading.

      Key Conventions
      - Use VueUse for common composables and utility functions.
      - Use Pinia for state management.
      - Optimize Web Vitals (LCP, CLS, FID).
      - Utilize Nuxt's auto-imports feature for components and composables.

      Nuxt-specific Guidelines
      - Follow Nuxt 3 directory structure (e.g., pages/, components/, composables/).
      - Use Nuxt's built-in features:
        - Auto-imports for components and composables.
        - File-based routing in the pages/ directory.
        - Server routes in the server/ directory.
        - Leverage Nuxt plugins for global functionality.
      - Use useFetch and useAsyncData for data fetching.
      - Implement SEO best practices using Nuxt's useHead and useSeoMeta.

      Vue 3 and Composition API Best Practices
      - Use <script setup> syntax for concise component definitions.
      - Leverage ref, reactive, and computed for reactive state management.
      - Use provide/inject for dependency injection when appropriate.
      - Implement custom composables for reusable logic.

      Follow the official Nuxt.js and Vue.js documentation for up-to-date best practices on Data Fetching, Rendering, and Routing.
```

© qdleader · MIT · qdleader/Awesome-AI-Pedia

Similar IDE rules

All IDE rules for Frontend and UI →

From the same set5

Project sponsors

Companies that keep this analytics open