vibe-next-template

This skill should be used when implementing code, creating files, or writing new features. Provides complete file structure, naming patterns, and import rules.

Decompose large requirements into phased task files that fit AI context windows using Gherkin + State Machine approach.

This skill should be used when working with database, Drizzle ORM, entities, schemas, migrations, and seeds. It provides Rails-style DB conventions, local sqlite/libSQL file defaults, and Effect-friendly data patterns.

Use this skill when generating enterprise admin, back-office, or operations module UI. Activates on: new module screen, admin panel, dashboard, operations list, approval queue, entity detail, multi-step form wizard, RBAC console, audit log, analytics cockpit, support console, settings page, or any layout described as "enterprise", "compact", or "admin-heavy". Provides recipe selection, page anatomy contract, density mode, state checklist, and AI prompt template.

This skill should be used when performing browser testing, verifying in browser, or runtime checks. Guides browser verification patterns.

This skill should be used when working with Chakra UI, UI components, or the design system. Guides Chakra UI v3 and Ark UI patterns.

This skill should be used when working with i18n, translation, locale, or internationalization. Guides next-intl setup, locale routing, and message management.

Use this skill when designing routes, planning URL structure, creating new pages or features, or deciding how to handle navigation patterns in Next.js App Router. Activates on: "design routes", "route structure", "URL design", "parallel routes", "intercepting routes", "modal with URL", "deep link modal", "tab routing", "conditional layout", "route group", "new feature planning", "decompose requirements" (always include route design questions), or any task that introduces new pages or navigation flows. Provides file-convention reference, routing pattern decision tree, parallel/intercepting route recipes, and workflow integration hooks for discovery and planning phases.

This skill should be used when working with Storybook, stories, or component documentation. Guides Storybook integration patterns.

This skill should be used when writing tests, using Vitest, or implementing Testing Library patterns. Guides Vitest and Testing Library setup.

Use this skill when generating ASCII text wireframes for enterprise web UI. Activates on: "wireframe", "ASCII UI", "text prototype", "design UI", "UI layout", "design enterprise screen", "prototype from requirements", "visualize states", or any request to turn a feature spec or state machine into a visual text mockup. Provides the ASCII component vocabulary, state visualization patterns, app shell grammar, and rendering rules for producing production-quality text wireframes.

This skill should be used when the task changes phase, new files are touched, a gate result changes, or a blocker appears. Keeps workflow state current across phases.

This skill should be used when writing backend code with Effect. Provides Effect-TS patterns for services, repositories, error handling, and testing.

This skill should be used when a task changes architecture, naming, folder structure, boundaries, or repository conventions. Classifies design decisions into hard conventions, strong defaults, and local freedom so plans and reviews stay contract-driven.

This skill should be used after quality gates and verification are complete or nearly complete. Validates readiness for delivery and produces a user-ready handoff.

This skill should be used when working with email, mailers, or transactional email. Provides React Email + Resend patterns (Rails ActionMailer equivalent).

This skill should be used when implementing entity lifecycle hooks (Rails callbacks equivalent). Provides patterns for before_save, after_create, and other lifecycle events.

This skill should be used when tests, lint, type checks, reviews, or verification fail. Recovers from failures by classifying the problem, choosing the rollback phase, and fixing deliberately.

This skill should be used when implementing complex form handling patterns (Rails form objects equivalent). Provides patterns for multi-step forms, complex validation, and form-to-entity transformation.

This skill should be used when the user asks to "create a plan", "plan implementation", or after requirements are clarified and before implementation starts. Creates a concrete implementation plan with sequencing, dependencies, risks, and validation strategy.

This skill should be used when discussing architecture, App Router, RSC, or server components. Provides Next.js App Router fundamentals and React Server Component patterns.

This skill should be used when deciding about "use client", client components, or client boundaries. Guides when to use client components.

This skill should be used when fetching data, setting up SWR, or implementing data fetching patterns. Guides data access patterns for Next.js.

This skill should be used when implementing error handling, error boundaries, or app error patterns. Guides error handling architecture.

This skill should be used when implementing logging, Pino, or structured logging patterns. Guides Pino structured logging setup.

This skill should be used when creating a module, feature module, or new feature. Guides module structure with containers, screens, components, and actions.

This skill should be used when creating server actions, mutations, or form actions. Guides next-safe-action + Zod patterns for type-safe server mutations.

This skill should be used when working with state machines, XState, or Zag.js. Guides XState and Zag.js integration patterns.

Use this skill when planning implementation to select the correct architectural patterns. Helps decide between state machines vs hooks, presenters vs inline, form objects vs schemas, etc.

This skill should be used when transforming entities for API responses or client display. Provides presenter patterns (Rails serializers equivalent).

This skill should be used after implementation changes or after any fix that could affect correctness. Runs and interprets automated quality gates in the canonical order.

This skill should be used when implementing composable query filters (Rails scopes equivalent). Provides patterns for reusable, chainable query conditions.

This skill should be used when working with real-time communication, WebSockets, or live updates. Provides patterns for SSE and Pusher/Ably integration (Rails ActionCable equivalent).

This skill should be used when the user asks to "clarify requirements", "start discovery", "define scope", or when the user intent is incomplete, ambiguous, or likely to cause implementation rework. Clarifies vague requests into scope, constraints, and acceptance criteria.

This skill should be used when working with background jobs, queues, or async tasks. Provides Trigger.dev job patterns, scheduling, and error handling.

This skill should be used when implementing UI layouts, animations, or making design decisions. Provides structured guidance for consistent UI patterns.