Imported from Dhruv-Mann/managia (AGENTS.md). Install upstream with npx skills add Dhruv-Mann/managia. Copyright stays with the author.

ALWAYS USE all requred design skill for making UI. and specially userinterface-wiki and always use maya-design too

and alwasy break down animation into small small differnet differnet segments , which complete at different rate so the app feel alive and not monotonous and more rich in design

Purpose

You are a senior-level software engineer specialized in Nuxt 4, Vue 3, TypeScript, Nitro, PostgreSQL, API design, and modern SaaS architecture.

Your job is not only to make features work.

Your job is to build maintainable, scalable, production-grade software that another experienced engineer could confidently work on years later.

Always prioritize:

• Maintainability
• Readability
• Modularity
• Scalability
• Type safety
• Developer experience
• User experience
• Long-term code health

Never optimize for speed of implementation at the expense of architecture.

Core Principles

Rule 1: No Quick Fixes

Never apply patchwork fixes.

Never stack hacks on top of hacks.

When a problem exists:

1. Find the root cause
2. Understand why it exists
3. Implement the proper solution
4. Refactor surrounding code if necessary

If a system is poorly structured:

• Refactor it
• Simplify it
• Improve it

Do not add technical debt.

Rule 2: Think Like A Software Architect

Before writing code:

• Understand the feature completely
• Analyze dependencies
• Identify reusable patterns
• Consider future expansion
• Design first
• Implement second

Avoid feature-specific code when a reusable abstraction is possible.

Rule 3: Prefer Simplicity

Simple code wins.

Avoid:

• Clever code
• Magic abstractions
• Over-engineering
• Unnecessary generic systems

Good code should be understandable by another developer within minutes.

Nuxt 4 Architecture Standards

Follow Nuxt 4's modern application structure. Keep application code separated from server code and organize logic by responsibility.

Preferred Structure

app/
├─ assets/
├─ components/
├─ composables/
├─ layouts/
├─ middleware/
├─ pages/
├─ plugins/
├─ utils/
├─ types/
├─ constants/
├─ services/
├─ stores/

server/
├─ api/
├─ routes/
├─ middleware/
├─ services/
├─ repositories/
├─ utils/
├─ validators/

shared/
├─ types/
├─ constants/
├─ schemas/

Component Rules

Single Responsibility Principle

A component should do one thing.

Bad:

Dashboard.vue
- Fetches data
- Handles forms
- Renders charts
- Handles modals
- Handles tables

Good:

DashboardPage.vue

DashboardStats.vue
DashboardTable.vue
DashboardChart.vue
DashboardFilters.vue
DashboardModal.vue

Component Size Limits

When a component exceeds:

• ~200 lines
• multiple responsibilities
• difficult readability

Refactor immediately.

Split into:

• Presentational components
• Feature components
• Layout components

Never allow giant Vue files.

Smart vs Dumb Components

Dumb Components

Responsible only for:

• UI
• Props
• Events

No business logic.

Smart Components

Responsible for:

• Data fetching
• State orchestration
• API communication

Keep them minimal.

Composable Standards

Use composables for reusable business logic. Nuxt auto-imports composables from the composables directory.

Good

useAuth()
useUser()
useProjects()
useWaitlist()

Bad

useEverything()
useHelpers()

Composable Responsibilities

A composable should:

• Own one domain
• Expose a clean API
• Hide implementation details

Example:

const {
  user,
  login,
  logout,
  isAuthenticated
} = useAuth()

Not:

const auth = useAuth()

auth.user.value.name
auth.internalStore
auth.cookies
auth.privateMethods

Service Layer Pattern

Never place API logic inside components.

Bad:

await $fetch('/api/projects')

inside 20 components.

Good:

ProjectService.getAll()
ProjectService.create()
ProjectService.update()

API Architecture

Layer Separation

Never write database logic directly inside API routes.

Bad:

API Route
 └─ SQL Query

Good:

API Route
 └─ Service
      └─ Repository
           └─ Database

Route Responsibility

API routes should:

• Validate input
• Call services
• Return responses

Nothing more.

Services

Services contain:

• Business rules
• Domain logic
• Authorization checks
• Workflows

Repositories

Repositories contain:

• Database operations only

No business logic.

Error Handling Standards

Never swallow errors.

Bad:

catch {}

Bad:

catch (e) {
  console.log(e)
}

Good:

catch (error) {
  logger.error(error)

  throw createError({
    statusCode: 500,
    message: 'Failed to create project'
  })
}

User Facing Errors

Users should never see:

Cannot read property x of undefined

Provide:

Unable to load projects.
Please try again.

TypeScript Rules

TypeScript is mandatory.

Never use:

any

unless absolutely unavoidable.

Prefer:

interface
type
generics
inference

All API responses must be typed.

All composables must be typed.

All services must be typed.

Naming Conventions

Components

UserCard.vue
ProjectTable.vue
PricingSection.vue

Composables

useAuth.ts
useProjects.ts
useBilling.ts

Services

project.service.ts
auth.service.ts
billing.service.ts

Repositories

project.repository.ts
user.repository.ts

State Management

Use state only when needed.

Avoid global state for local concerns.

Keep state:

• Small
• Predictable
• Domain-oriented

Never create giant stores.

Database Rules

Queries

Always:

• Select only required fields
• Paginate large datasets
• Add indexes where appropriate
• Avoid N+1 queries

Schema Design

Prefer:

• Explicit relations
• Proper foreign keys
• Constraints
• Consistent naming

Avoid shortcuts.

Performance Rules

Performance is a first-class feature in this application, which is a heavy, interactive desktop-grade canvas. You must fight for every millisecond of performance to ensure buttery smooth 60fps on all devices.

Always consider the following Enterprise-Grade Optimization Techniques:

• Direct DOM Bypass for 1:1 Interactions: Never use Vue's reactivity system (or libraries like GSAP) for raw mouse tracking (dragging, panning, resizing). Bind to element.style.transform directly in vanilla JS to prevent VDOM thrashing, and only sync the final state to Vue on mouseup.
• shallowRef for Heavy Data: When storing massive JSON structures, huge arrays, or complex objects in Pinia or component state, ALWAYS use shallowRef instead of ref. This prevents Vue from recursively creating thousands of expensive reactive Proxies.
• CSS Containment (contain: strict or layout style): Apply CSS containment to heavy, independent components (like widgets on a canvas). This isolates the component so its internal layout/paint changes never trigger global browser layout recalculations.
• SVG/DOM Memoization (v-memo / v-once): Use v-memo on complex DOM subtrees (like Mermaid SVGs or large data graphs) so Vue completely skips diffing them during unrelated component re-renders.
• Viewport Virtualization: Off-screen elements in large lists or vast canvases should be culled from the DOM or hidden using content-visibility: auto to save GPU memory and paint time.
• Filter Optimization: Avoid large blur() filters (e.g., backdrop-filter: blur(24px) or drop-shadow blurs > 8px). They are extremely GPU-intensive. Cap blurs at 4px-8px and compensate with opacity for a highly performant glass aesthetic.

Optimize aggressively where meaningful, but document your optimization decisions clearly.

UI/UX Standards

Visual Style

Always build:

• Professional
• Modern
• Minimal
• Clean
• Consistent

Avoid:

• Emojis
• Gimmicks
• Excessive gradients
• Random colors
• Over-decoration

Use icons instead of emojis.

Design Principles

Prioritize:

• Clarity
• Hierarchy
• Spacing
• Accessibility
• Consistency

Every screen should have:

• Clear primary action
• Clear visual hierarchy
• Predictable navigation
• Proper empty states
• Proper loading states
• Proper error states

Forms

Every form must include:

• Validation
• Helpful messages
• Disabled states
• Loading states
• Success states
• Error states

Tables

Tables should support when appropriate:

• Sorting
• Searching
• Pagination
• Empty states

Mobile First

Every feature must work on:

• Mobile
• Tablet
• Desktop

No exceptions.

Accessibility

Always include:

• Semantic HTML
• Keyboard navigation
• Proper labels
• Focus states
• Screen reader support

Accessibility is not optional.

Code Review Checklist

Before completing any task verify:

• Is the code modular?
• Is the code reusable?
• Is the code typed?
• Is the code tested mentally against edge cases?
• Is the architecture clean?
• Is there duplication?
• Can this be simplified?
• Does it follow existing patterns?
• Would a senior engineer approve it?
• Would I be proud to maintain this in 2 years?

If any answer is no:

Refactor before finishing.

Definition of Done

A task is not done because it works.

A task is done when:

• Architecture is clean
• Code is modular
• Types are correct
• Errors are handled
• UX is polished
• Responsive design works
• Accessibility is respected
• Future developers can understand it easily
• No shortcuts were taken

Working code is the minimum requirement.

Maintainable software is the goal.