Feature From Zero

Feature From Zero

Mega-composite for the largest natural unit of work: an entire feature, from "we should build X" to "live in prod, decision captured." Chains 5 other composites in the right order, with checkpoints between phases.

Auto-invocation triggers

• User says "build feature X", "implement Y end-to-end", "ship the new W"
• Spec hand-off ("here's the spec, build it")
• Greenfield work (>2 days estimated)

Skip when scope is a small fix or refactor of existing code — use the more focused composite (scope-and-execute or refactor-pipeline) directly.

Workflow

Phase 1 — Decide (always for greenfield)

Invoke research-and-decide:

• Validate the feature is worth building (vs alternatives, vs deferring)
• Decide on the approach (library choice, pattern, integration points)
• Write the ADR capturing rationale

If the decision is "don't build" or "defer": stop here. The ADR captures why.

Phase 2 — Scope + plan (always)

Invoke scope-and-execute:

• Phase 1: analysis (adt-repo-intake or ecosystem-health)
• Phase 2: context-pack
• Phase 3: plan with phased steps and validation per phase
• Stops here for review before Phase 4 implementation

User reviews the plan. If rejected, loop back to plan phase with feedback. If accepted, continue.

Phase 3 — Implement (always)

Invoke scope-and-execute Phase 4 (execute):

• For independent tracks: dispatch (parallel sub-agents)
• For sequential work: loop
• For complex 3+ phases: three-man-team

Implementation follows the Phase 2 plan. Per-phase commits with validation gates.

Phase 4 — UI build (only if feature has UI)

Detect if Phase 3 produced UI artifacts (new components, pages, layouts). If yes: invoke design-build:

• Design context (web-design-guidelines or ui-audit)
• Scaffold (shadcn or tailwind)
• Build (impeccable for production UI, frontend-design for art-directed)
• Verify (webapp-testing — a11y, console, breakpoints)

Phase 5 — Test suite check (always)

Invoke test-health:

• If verdict is HEALTHY: skip Phase 6
• If verdict is anything else: invoke fix-the-suite

This prevents the new feature from leaving the suite in a worse state.

Phase 6 — Ship to merge (always)

Invoke merge-confidently:

• pr-merge-readiness verdict
• Resolve WAIT / FIX cycles
• Ship through merge gates

Phase 7 — Ship to prod (always for production-bound work)

Invoke ship-it:

• Version bump + changelog
• Tag + GitHub release
• Deploy via correct deployer
• Post-deploy verify

If ship-it Phase 4 detects new Sentry issues: escalate to production-incident.

Phase 8 — Capture (always — most-skipped step in real work)

Invoke knowledge-loop:

• Update memory with what was built and why
• Index into RAG for future search
• Write handoff if session is ending

Reconciliation

Single feature summary across all phases:

FEATURE FROM ZERO — <feature name>

Phase 1 Decide:      ADR-NNNN <decision>
Phase 2 Plan:        <plan path, N phases, M files in scope>
Phase 3 Implement:   <commits, files changed>
Phase 4 UI:          <surfaces built / SKIPPED if no UI>
Phase 5 Tests:       <test-health verdict, fix-the-suite if applied>
Phase 6 Merge:       PR #N at <SHA>
Phase 7 Ship:        v<X.Y.Z> deployed to <target>, verified
Phase 8 Captured:    memory + RAG indexed, handoff if session-ending

Total commits: N
Total time: H hours wall-clock

Outputs / Evidence

• Per-phase artifact (ADR, plan, commits, PR, tag, deploy proof, memory)
• Single end-to-end summary
• Captured for next-session search

Failure / Stop Conditions

• Phase 1 decision is "don't build" → exit clean with ADR explaining why
• Phase 2 plan rejected by user → loop back; max 3 plan iterations before surfacing scope-too-fluid for stop-and-redefine
• Phase 3 implementation hits a blocker the plan didn't account for → trigger re-plan (back to Phase 2) rather than improvising past the plan
• Phase 7 deploy fails → STOP, do not auto-rollback (escalate to production-incident)
• Phase 8 is mandatory — never skip capture even if user is in a hurry; this is why prior decisions get lost

Memory Hooks

• Read existing feature-related decisions to avoid re-litigating
• Write feature outcome with all phase artifacts; trend across features reveals bottlenecks (e.g., "Phase 5 fix-the-suite consistently takes 2x estimate")