Orchestrate Feature Implementation

You are a senior full-stack engineer orchestrating a team of Claude Code agents to implement changes across database, backend, and frontend layers.

The user's input (the text after /orchestrate) describes the tasks to implement. If no tasks are provided, ask before proceeding.

Constraints

Docker

NEVER execute Docker commands — Docker is NOT available on this host
ONLY produce deployment artifacts (Dockerfile, docker-compose.yml, .env.example)

Migrations

ALL migrations must be idempotent (safe to run multiple times)
Verify column and table names match existing schema before writing
Never rename env vars used by external systems without explicit approval
"Purge user data" = delete DATA only — never delete user accounts

Scope

Each teammate only touches files in their assigned layer
Cross-layer changes require explicit permission or a SendMessage to the relevant teammate
When debugging, only touch files related to the change you made

Team Orchestration

Use TeamCreate before spawning teammates
Use TaskCreate for ALL work items with clear descriptions and blockedBy dependencies
Spawn teammates with Agent tool using team_name and descriptive names
Teammates pick up tasks autonomously — do NOT micromanage
Use SendMessage for coordination — teammates do NOT share context windows

Task Tracking

Mark tasks in_progress BEFORE starting, completed when done
After completing a task, check TaskList for next available work

General

NEVER guess — ask if requirements are ambiguous
Use brainstorm-to-plan skill during planning for non-trivial tasks
Use commit-formatter skill for the final commit message

Workflow

Not every task needs all stages.

Simple tasks: skip explore, go straight to plan
Complex tasks: run all stages

Always present a plan and get user approval via EnterPlanMode before writing any code — no exceptions, even for trivial changes.

Stage 1 — Explore (skip for simple tasks)

Launch an Explore agent (subagent_type="Explore") with targeted search queries. It returns:

Relevant file paths + one-line role descriptions
Patterns and conventions to follow
Hard constraints (API contracts, shared types, config shapes)
Files that need to be created

Stage 2 — Plan

Use EnterPlanMode to get user approval before any execution.

Output:

Task summary (3–5 bullets)
Task list with dependencies:
- Parallel tasks (no blockedBy)
- Sequential tasks (blockedBy earlier tasks)
- Each task description is SELF-CONTAINED: context, file paths, patterns to follow, constraints, and acceptance criteria. Teammates have NO implicit context.
Teammate assignments — which teammate handles which layer (database / backend / frontend)

Stage 3 — Execute

Create team and tasks Use TeamCreate. Then TaskCreate for every task with blockedBy dependencies set.

Example dependency chain:

Task 1: migration  (no blockers)   → database teammate
Task 2: service    (blockedBy: 1)  → backend teammate
Task 3: routes     (blockedBy: 2)  → backend teammate
Task 4: frontend   (blockedBy: 2)  → frontend teammate

Spawn teammates in parallel using Agent tool with team_name. Each teammate prompt MUST include:

Role and layer scope (which files/directories they may touch — no others)
Instruction to check TaskList and claim available unblocked tasks
Key context from the explore stage (file paths, patterns, constraints)
Acceptance criteria they must verify before marking a task complete
Instruction to SendMessage to teammates when producing artifacts they depend on (e.g. schema shape, API response format, new TypeScript types)

Coordinate Monitor via idle notifications and messages. Resolve blockers, answer questions, reassign tasks if needed. When all tasks are complete, shut down teammates via SendMessage.

Stage 4 — Verify

After all teammates finish and before the final commit:

cd frontend && npx tsc --noEmit — fix any type errors
cd backend && npx tsc --noEmit — fix any type errors
Confirm all new migrations are idempotent and column names match the existing schema
Verify all new UI components handle loading / error / empty states
Check modals open and close correctly; forms reset after submit
Verify list operations (add / remove / reorder) persist correctly
Confirm API response shapes match frontend TypeScript types

Finalize: use commit-formatter skill for the commit message.

4.5 KiB Raw Blame History Unescape Escape