Dev

YOU ARE EXECUTING THE /dev SKILL. The user triggered this skill. Follow ALL instructions below step by step. Do NOT treat this as a freeform conversation - execute the skill workflow.

Follow CLAUDE.md rules.

Ultra Think Strategy

Ultra think before each phase transition:

• After exploration results: reflect on completeness before planning
• Before implementation: consider edge cases, patterns to follow, potential issues
• After validation: ensure the approach aligns with user intent

1. UNDERSTAND

• Read spec: $ARGUMENTS.spec
• Identify phase: $ARGUMENTS.phase
• Phases completed: $ARGUMENTS.done
• Extract from phase description:
  • Scope: backend / frontend / both
  • Files to create/modify
  • Libraries needed

2. EXPLORE (PARALLEL)

Launch focused agents in a single message (parallel execution). Scale agent count to task complexity.

Complexity Guide

Backend Agents (min 2 when backend in scope, split by concern)

1. Domain & data flow - explore-codebase: "Find entities, repository interfaces, value objects, and DTOs related to [feature] in backend/internal/domain/ and backend/internal/application/dto/"
2. Usecases & business logic - explore-codebase: "Find usecases related to [feature] in backend/internal/application/usecases/. Read their Execute methods, dependencies, and error handling"
3. Handlers & routing - explore-codebase: "Find HTTP handlers and routes related to [feature] in backend/internal/presentation/. Check middleware, validation, response patterns"
4. Infrastructure & services - explore-codebase: "Find repo implementations, external service adapters, and config related to [feature] in backend/internal/infrastructure/"
5. Similar patterns - explore-codebase: "Find the most similar existing feature to [feature] in backend/. I need to replicate its patterns"

Frontend Agents (min 2 when frontend in scope, split by concern)

1. Components & UI - explore-codebase: "Find components related to [feature] in frontend/src/components/. Check props, state, Shadcn UI usage"
2. Hooks & state - explore-codebase: "Find hooks, React Query calls, and state management related to [feature] in frontend/src/hooks/ and frontend/src/lib/"
3. Pages & routing - explore-codebase: "Find pages and layouts related to [feature] in frontend/src/app/. Check route structure, data fetching, i18n"
4. Types & API layer - explore-codebase: "Find TypeScript types, API client functions related to [feature] in frontend/src/types/ and frontend/src/lib/"
5. Similar patterns - explore-codebase: "Find the most similar existing feature to [feature] in frontend/src/. I need to replicate its patterns"

Supporting Agents (as needed, 1 each)

2.5 POST-EXPLORATION CHECK

After agents return, verify coverage across all dimensions:

1. Full code path traced? Can I trace handler -> usecase -> repository -> DB (backend) and page -> hook -> API -> component (frontend)? If gaps -> launch targeted explore-codebase
2. Similar patterns identified? Do I have a reference implementation to follow? If not -> launch explore-codebase
3. Data model complete? Tables, columns, relationships, RLS known? If not -> launch explore-db
4. Library docs sufficient? If not -> launch explore-docs

Do NOT proceed with incomplete context.

3. SHOW PLAN

Display enriched plan:

## Phase $ARGUMENTS.phase

### Files to Create
- `path/file` - [purpose]

### Files to Modify
- `path/file:XX` - [what to change]

### Patterns to Reuse (from exploration)
- [existing code patterns found]

### Order
Backend: Domain -> Application -> Infrastructure -> Presentation
Frontend: Types -> API -> Hooks -> Components -> Pages

4. VALIDATE

Ask with AskUserQuestion: "Proceed with implementation?"

• "Implement"
• "Modify"

5. IMPLEMENT

After validation, implement in appropriate order:

Backend: Domain -> Application -> Infrastructure -> Presentation

• context.Context as first parameter for I/O
• Follow Clean Architecture patterns
• Complete error handling

Frontend: Types -> API -> Hooks -> Components -> Pages

• next-intl for ALL user-facing text
• Shadcn UI for standard components
• Strict TypeScript (no any)

For significant UI: Skill(skill="frontend-design:frontend-design")

6. VERIFY

# Backend
cd backend && go build ./... && go vet ./...
# Frontend
cd frontend && npm run build

Database verification: mcp__supabase-dev__XXXX

7. UPDATE SPEC

Check off completed items in the Execution Plan of the spec file.

Rules

• EXPLORE FIRST - Always explore before implementing
• REUSE - Existing code/patterns as much as possible
• VALIDATE - Always ask before implementing
• STAY IN SCOPE - Only the specified phase

Converted and distributed by TomeVault — claim your Tome and manage your conversions.