/feature-dev

Feature Development

You are orchestrating feature development using an architecture-first approach. Focus on high-level coordination and let specialized agents handle implementation details.

Initial Request

$ARGUMENTS

Workflow

Use TodoWrite to track progress through these phases:

1. Context Gathering

Analyze the codebase to understand current architecture and patterns:

• Identify framework, tech stack, and project structure
• Map existing components, APIs, and database patterns
• Review code conventions and architectural decisions
• Document findings with file:line references

This helps you ask informed clarifying questions in the next phase.

2. Requirement Clarification

Based on gathered context, use AskUserQuestion to clarify ALL requirements before proceeding:

• What exactly should this feature do? What problem does it solve?
• UI/UX requirements: layout, user flow, interactions, design system
• Data requirements: what data, validation rules, relationships
• API requirements: endpoints, authentication, request/response formats
• Performance, security, or integration constraints
• Any specific technical preferences or requirements

Get complete, unambiguous requirements before moving to architecture design.

3. Architecture Design

Launch the system-architect agent with complete requirements:

• Provide the feature requirements gathered from user
• Include relevant context from your analysis
• Architect will design high-level system architecture
• Architect reports back with architecture blueprint (no user interaction)

The architecture blueprint will include API contracts, frontend structure, data models, and system boundaries.

4. Design Approval

Present the architecture blueprint to the user:

• Show the proposed architecture clearly
• Explain key architectural decisions and trade-offs
• Use AskUserQuestion to ask: "Does this design look good? Any changes needed?"
• Get explicit approval before proceeding to implementation

If changes are needed, refine the architecture and get approval again.

5. Implementation

Based on the approved architecture, determine affected domains and create implementation tasks.

Task Planning:

• Break down complex features into small, focused tasks
• Group tasks by domain (backend, frontend, devops)
• Use TodoWrite to track all implementation tasks

Sequential Execution: For each task, launch the appropriate agent with:

• Architecture blueprint
• Complete requirements from phase 2
• Specific task description
• Context from previously completed tasks (if applicable)

Domain Agents:

• backend-developer - API endpoints, business logic, services, data models, migrations
• frontend-developer - UI components, pages, routing, state management
• devops-engineer - Deployment, infrastructure, containerization, CI/CD

For complex domains (e.g., multi-page frontend with many components):

• Launch the same agent sequentially multiple times
• Each invocation handles one focused task
• Pass results from previous tasks as context to next task

Agent Autonomy:

• Agents work autonomously without user interaction
• Agents analyze, design, implement, test, and report back to you
• You coordinate at high level and aggregate results

6. Summary

Once all implementation tasks complete, provide final summary:

• What was built (features, endpoints, components, infrastructure)
• Key architectural and implementation decisions
• Files created/modified with file:line references
• Testing results
• Next steps or recommendations

Key Principles

• Architecture-first - Understand the system design before implementation
• Complete requirements - Clarify everything upfront to avoid agent confusion
• Main agent orchestrates - ALL user communication happens at command level
• Agent autonomy - Agents execute tasks without asking user questions
• Sequential task delegation - Break complex features into focused tasks
• Minimal orchestration - Coordinate at high level, don't prescribe implementation details

CRITICAL: You handle ALL user interaction. Agents receive complete requirements and execute autonomously. Never delegate user questions to agents.