/full-stack-feature

description: "Orchestrate end-to-end full-stack feature development across backend, frontend, database, and infrastructure layers"
argument-hint: "<feature description> [--stack react/fastapi/postgres] [--api-style rest|graphql] [--complexity simple|medium|complex]"

Full-Stack Feature Orchestrator

CRITICAL BEHAVIORAL RULES

You MUST follow these rules exactly. Violating any of them is a failure.

1. **Execute steps in order.** Do NOT skip ahead, reorder, or merge steps. 2. **Write output files.** Each step MUST produce its output file in `.full-stack-feature/` before the next step begins. Read from prior step files -- do NOT rely on context window memory. 3. **Stop at checkpoints.** When you reach a `PHASE CHECKPOINT`, you MUST stop and wait for explicit user approval before continuing. Use the AskUserQuestion tool with clear options. 4. **Halt on failure.** If any step fails (agent error, test failure, missing dependency), STOP immediately. Present the error and ask the user how to proceed. Do NOT silently continue. 5. **Use only local agents.** All `subagent_type` references use agents bundled with this plugin or `general-purpose`. No cross-plugin dependencies. 6. **Never enter plan mode autonomously.** Do NOT use EnterPlanMode. This command IS the plan -- execute it.

Pre-flight Checks

Before starting, perform these checks:

1. Check for existing session

Check if `.full-stack-feature/state.json` exists:

• If it exists and `status` is `"in_progress"`: Read it, display the current step, and ask the user:

  Found an in-progress full-stack feature session:
  Feature: [name from state]
  Current step: [step from state]

  1. Resume from where we left off
  2. Start fresh (archives existing session)

• If it exists and `status` is `"complete"`: Ask whether to archive and start fresh.

2. Initialize state

Create `.full-stack-feature/` directory and `state.json`:

{
  "feature": "$ARGUMENTS",
  "status": "in_progress",
  "stack": "auto-detect",
  "api_style": "rest",
  "complexity": "medium",
  "current_step": 1,
  "current_phase": 1,
  "completed_steps": [],
  "files_created": [],
  "started_at": "ISO_TIMESTAMP",
  "last_updated": "ISO_TIMESTAMP"
}

Parse `$ARGUMENTS` for `--stack`, `--api-style`, and `--complexity` flags. Use defaults if not specified.

3. Parse feature description

Extract the feature description from `$ARGUMENTS` (everything before the flags). This is referenced as `$FEATURE` in prompts below.

---

Phase 1: Architecture & Design Foundation (Steps 1-3) -- Interactive

Step 1: Requirements Gathering

Gather requirements through interactive Q&A. Ask ONE question at a time using the AskUserQuestion tool. Do NOT ask all questions at once.

**Questions to ask (in order):**

1. **Problem Statement**: "What problem does this feature solve? Who is the user and what's their pain point?" 2. **Acceptance Criteria**: "What are the key acceptance criteria? When is this feature 'done'?" 3. **Scope Boundaries**: "What is explicitly OUT of scope for this feature?" 4. **Technical Constraints**: "Any technical constraints? (e.g., existing API conventions, specific DB, latency requirements, auth system)" 5. **Stack Confirmation**: "Confirm the tech stack -- detected [stack] from project. Frontend framework? Backend framework? Database? Any changes?" 6. **Dependencies**: "Does this feature depend on or affect other features/services?"

After gathering answers, write the requirements document:

**Output file:** `.full-stack-feature/01-requirements.md`

# Requirements: $FEATURE

## Problem Statement

[From Q1]

## Acceptance Criteria

[From Q2 -- formatted as checkboxes]

## Scope

### In Scope

[Derived from answers]

### Out of Scope

[From Q3]

## Technical Constraints

[From Q4]

## Technology Stack

[From Q5 -- frontend, backend, database, infrastructure]

## Dependencies

[From Q6]

## Configuration

- Stack: [detected or specified]
- API Style: [rest|graphql]
- Complexity: [simple|medium|complex]

Update `state.json`: set `current_step` to 2, add `"01-requirements.md"` to `files_created`, add step 1 to `completed_steps`.

Step 2: Database & Data Model Design

Read `.full-stack-feature/01-requirements.md` to load requirements context.

Use the Task tool to launch a database architecture agent:

Task:
  subagent_type: "general-purpose"
  description: "Design database schema and data models for $FEATURE"
  prompt: |
    You are a database architect. Design the database schema and data models for this feature.

    ## Requirements
    [Insert full contents of .full-stack-feature/01-requirements.md]

    ## Deliverables
    1. **Entity relationship design**: Tables/collections, relationships, cardinality
    2. **Schema definitions**: Column types, constraints, defaults, nullable fields
    3. **Indexing strategy**: Which columns to index, index types, composite indexes
    4. **Migration strategy**: How to safely add/modify schema in production
    5. **Query patterns**: Expected read/write patterns and how the schema supports them
    6. **Data access patterns**: Repository/DAO interface design

    Write your complete database design as a single markdown document.

Save the agent's output to `.full-stack-feature/02-database-design.md`.

Update `state.json`: set `current_step` to 3, add step 2 to `completed_steps`.

Step 3: Backend & Frontend Architecture

Read `.full-stack-feature/01-requirements.md` and `.full-stack-feature/02-database-design.md`.

Use the Task tool to launch an architecture agent:

Task:
  subagent_type: "general-purpose"
  description: "Design full-stack architecture for $FEATURE"
  prompt: |
    You are a full-stack architect. Design the complete backend and frontend architecture for this feature.

    ## Requirements
    [Insert contents of .full-stack-feature/01-requirements.md]

    ## Database Design
    [Insert contents of .full-stack-feature/02-database-design.m