ID8ARCHITECT - Technical Design Engine

Purpose

Transform validated ideas into concrete, buildable technical plans. Architecture should enable velocity, not slow it down.

Philosophy: Boring technology, managed services, ship fast, iterate often.

When to Use

• •Project has a BUILD verdict from scout
• •User needs to design system architecture
• •User asks "how should I build this?"
• •User needs database schema design
• •User needs API design guidance
• •User needs infrastructure decisions
• •Project is in VALIDATED or ARCHITECTING state

Commands

/architect <project-slug>

Run full architecture design for a validated project.

Process:

1. •REQUIREMENTS - Extract from validation report
2. •ARCHITECTURE - Design system components
3. •STACK - Select technologies
4. •DATA - Model the database
5. •API - Design interfaces
6. •INFRASTRUCTURE - Plan deployment
7. •ROADMAP - Phase the implementation

/architect stack <requirements>

Get stack recommendations for specific requirements.

/architect schema <domain-description>

Design database schema for a domain.

/architect api <resource-description>

Design API endpoints for a resource.

Design Philosophy

Solo Builder Optimization

This is NOT enterprise architecture. Optimize for:

Technology Preferences

Preferred Stack (default unless reason to deviate):

When to Deviate:

• •Heavy computation → Add dedicated backend
• •Complex real-time → Consider Convex or custom WebSocket
• •ML/AI workloads → Separate Python service
• •Specific compliance → May need self-hosted

Process Detail

Phase 1: REQUIREMENTS

Extract from validation report:

• •Core problem being solved
• •Target user persona
• •Must-have features (max 5 for MVP)
• •Success metrics
• •Constraints (budget, timeline, skills)

Output:

## Requirements Summary

### Problem
{What are we solving}

### User
{Who is this for}

### MVP Features
1. {Feature 1}
2. {Feature 2}
3. {Feature 3}

### Constraints
- Budget: ${X}/month max
- Timeline: {X} weeks to MVP
- Skills: {current skill level}

Phase 2: ARCHITECTURE

Design high-level system:

┌─────────────────────────────────────────────────┐
│                    CLIENT                        │
│            (Next.js App Router)                 │
└─────────────────────────────────────────────────┘
                        │
                        ▼
┌─────────────────────────────────────────────────┐
│                 API LAYER                        │
│         (Next.js API Routes / Edge)             │
└─────────────────────────────────────────────────┘
                        │
            ┌───────────┼───────────┐
            ▼           ▼           ▼
       ┌────────┐  ┌────────┐  ┌────────┐
       │ Auth   │  │Database│  │Storage │
       │(Supa)  │  │(Supa)  │  │(Supa)  │
       └────────┘  └────────┘  └────────┘

Decisions to Document:

• •Client rendering strategy (SSR/SSG/CSR)
• •State management approach
• •API design (REST vs tRPC)
• •Authentication flow
• •Error handling strategy

Phase 3: STACK

Use the frameworks/stack-selection.md decision matrix.

For each technology choice:

1. •State the requirement
2. •List 2-3 options
3. •Pick one with brief rationale
4. •Document trade-offs

Phase 4: DATA

Design database schema using frameworks/database-patterns.md.

Key Tables to Define:

• •Core domain entities
• •User/auth tables (if not using Supabase defaults)
• •Relationship tables
• •Audit/logging tables

For Each Table:

• •Fields with types
• •Primary keys
• •Foreign keys
• •Indexes
• •RLS policies (Supabase)

Phase 5: API

Design API using frameworks/api-design.md.

For Each Endpoint:

• •Method + Path
• •Request body/params
• •Response shape
• •Error cases
• •Auth requirements

Phase 6: INFRASTRUCTURE

Plan deployment using frameworks/infrastructure.md.

Define:

• •Hosting configuration
• •Environment management
• •CI/CD pipeline
• •Monitoring setup
• •Backup strategy

Phase 7: ROADMAP

Create phased implementation plan using templates/build-roadmap.md.

Phases:

• •MVP (Weeks 1-4): Core loop, basic auth, essential features
• •V1 (Weeks 5-8): Polish, secondary features, onboarding
• •V2 (Weeks 9-12): Growth features, integrations, optimization

Framework References

System Design

frameworks/system-design.md - Component patterns, coupling, boundaries

Stack Selection

frameworks/stack-selection.md - Technology decision matrix

Database Patterns

frameworks/database-patterns.md - Schema design, Supabase patterns

API Design

frameworks/api-design.md - REST patterns, error handling, versioning

Infrastructure

frameworks/infrastructure.md - Deploy, CI/CD, monitoring

Output Templates

Architecture Document

templates/architecture-doc.md - Full technical specification

Build Roadmap

templates/build-roadmap.md - Phased implementation plan

Tool Integration

Subagents

backend-architect:

• •System design decisions
• •API contract design
• •Integration patterns

database-architect:

• •Schema design
• •Query optimization
• •Data modeling

Skills

database-design:

• •Supabase-specific patterns
• •RLS policy design
• •Migration strategies

supabase-expert:

• •Edge functions
• •Real-time subscriptions
• •Storage configuration

Handoff

After completing architecture:

1. •

   Save outputs:

   • •Architecture doc → docs/ARCHITECTURE.md in project
   • •Build roadmap → docs/BUILD_ROADMAP.md in project
2. •

   Log to tracker:

   code

   /tracker log {project-slug} "ARCHITECT: Architecture complete. Stack: {stack}. MVP scope: {features}. Estimated timeline: {weeks} weeks."
   

3. •

   Update state:

   code

   /tracker update {project-slug} BUILDING
   

4. •

   Next steps:

   • •Proceed to 11-stage pipeline Stage 4 (Foundation Pour)
   • •Begin scaffolding based on architecture doc

Anti-Patterns

Avoid These

Right-Size Your Architecture

Simple CRUD app → Next.js + Supabase, done
Real-time features → Add Supabase Realtime
Complex forms → Add React Hook Form + Zod
Heavy compute → Add Edge Functions or separate service
ML/AI → Separate Python service
Enterprise needs → Then consider more complex patterns

Quality Checks

Before signing off on architecture:

• • Every component has a clear purpose
• • No premature optimization
• • Stack is boring and proven
• • MVP scope is minimal (3-5 features)
• • Timeline is realistic for solo builder
• • Infrastructure is managed (not self-hosted)
• • Security basics are addressed (auth, validation)
• • Monitoring strategy exists