Prerequisite Graph

Prerequisite Graph Skill

Documents the complete dependency graph of the mapped /architect: commands (not yet exhaustive of all 63), showing which commands must run before others, in what order, with estimated execution times for full dependency chains.

Quick Reference: Command Dependency Tiers

Commands are organized by execution order:

Full Dependency Graph

Tier 0: Foundation (Nothing required)

START
  ↓
blueprint — 20 min
  ├─ Problem validation (optional baseline)
  ├─ SDL generation (alternative to blueprint)
  └─ Import existing project (alternative entry)

Commands:

• blueprint (20 min) — generates tech stack, components, design palette
• sdl (varies) — validates or generates solution.sdl.yaml
• import (10 min) — reverse-engineers SDL from existing codebase
• problem-validation (30 min) — validates market problem before architecture

Outputs:

• solution.sdl.yaml or _state.json with project basics
• Foundational design palette

Exit criteria:

• ✅ State has project.name, tech_stack, components, design

Tier 1: Design & Data Model (depends on Tier 0)

blueprint (Tier 0)
  ↓
design-system — 15 min
  ├─ Generate design tokens
  ├─ Create Tailwind config
  └─ Define component library
  
generate-data-model — 20 min
  ├─ Entity schema (Prisma, SQLAlchemy, etc.)
  ├─ Relationships and constraints
  └─ Migration templates

Dependencies:

• design-system requires: blueprint (design section)
• generate-data-model requires: SDL entities OR state.entities

Outputs:

• Design tokens, Tailwind config, CSS variables
• Database schema (Prisma, SQL, etc.)
• Entity types and relationships

Exit criteria:

• ✅ Design tokens generated
• ✅ Data schema exists

Tier 2: Code Generation (depends on Tier 0 + Tier 1)

blueprint (Tier 0)
design-system (Tier 1) — 15 min
generate-data-model (Tier 1) — 20 min
  ↓
scaffold — 30-60 min
  ├─ Generate project structure
  ├─ Install dependencies
  ├─ Apply design tokens
  ├─ Generate schemas
  └─ Create env.example files
  ↓
scaffold-component (2-10 min each)
  ├─ Generate individual components
  ├─ Apply design tokens
  └─ Create stubs for routes/services

Dependencies:

• scaffold requires: Blueprint + design tokens + data model
• scaffold-component requires: Existing scaffold

Outputs:

• Full project directory structure
• package.json / requirements.txt / go.mod
• Source files with correct imports
• Individual component folders

Exit criteria:

• ✅ npm install succeeds
• ✅ Build passes (no syntax errors)
• ✅ Project structure matches blueprint

Tier 3: Development (depends on Tier 2)

scaffold (Tier 2) — 30-60 min
  ↓
implement — N days
  ├─ Add feature logic
  ├─ Update entity schema
  ├─ Create database migrations
  └─ Write component code
  ↓
visualise — 5 min
  ├─ Generate C4 diagrams
  ├─ Create mermaid visualizations
  └─ Update architecture diagrams
  ↓
review — 10-30 min
  ├─ Analyze code quality
  ├─ Check architecture compliance
  └─ Generate PR feedback

Dependencies:

• implement requires: Existing scaffold
• visualise requires: Blueprint + scaffold
• review requires: Scaffold + implemented code

Outputs:

• Feature code (controllers, services, components)
• Updated schema with new entities
• Database migrations
• C4 diagrams, mermaid files
• Code review reports (optional PR feedback)

Exit criteria:

• ✅ Features implemented
• ✅ Code passes linting
• ✅ Tests pass (once written)

Tier 4: Quality (depends on Tier 3)

implement (Tier 3) — N days
  ↓
generate-tests — 30-120 min
  ├─ Unit tests (Jest, Vitest, pytest)
  ├─ Integration tests
  ├─ E2E tests (optional)
  └─ Test fixtures and mocks
  ↓
security-scan — 20-60 min
  ├─ SAST analysis
  ├─ Dependency vulnerability scan
  ├─ Secret scanning
  └─ Security report
  ↓
accessibility-audit — 15-45 min
  ├─ WCAG 2.1 AA compliance check
  ├─ Screen reader testing
  └─ Keyboard navigation audit

Dependencies:

• generate-tests requires: Source files from scaffold + test framework
• security-scan requires: Source code to analyze
• accessibility-audit requires: Rendered UI (scaffold + implement)

Outputs:

• Test suites (unit, integration, e2e)
• Test fixtures and mocks
• Coverage report
• Security scan results
• Vulnerability report
• Accessibility report

Exit criteria:

• ✅ 60%+ test coverage (or project-specific target)
• ✅ No critical security vulnerabilities
• ✅ WCAG 2.1 AA compliance

Tier 5: Scale (depends on Tier 2 + Tier 4)

scaffold (Tier 2) — 30-60 min
generate-tests (Tier 4) — 30-120 min
design-system (Tier 1) — 15 min
  ↓
setup-cicd — 20-30 min
  ├─ Configure CI/CD pipeline
  ├─ Setup code coverage tracking
  ├─ Configure deployment stages
  └─ Setup secrets management
  ↓
setup-monitoring — 20-60 min
  ├─ Configure observability (Datadog, New Relic, Prometheus)
  ├─ Setup dashboards
  ├─ Create alert rules
  ├─ Configure SLOs
  └─ Setup distributed tracing
  ↓
load-test — 30-90 min
  ├─ Define load test scenarios
  ├─ Configure target RPS
  ├─ Generate test data
  └─ Execute tests and report

Dependencies:

• setup-cicd requires: Scaffold + builds
• setup-monitoring requires: Service structure + framework choice
• load-test requires: Deployed or deployed-simulation infrastructure

Outputs:

• CI/CD configuration (.github/workflows, .gitlab-ci.yml, etc.)
• Pipeline definitions (build, test, deploy stages)
• Monitoring dashboards
• Alert rules and SLOs
• Load test results and capacity estimates

Exit criteria:

• ✅ CI/CD passes build + tests
• ✅ Monitoring collects metrics
• ✅ Load test targets met (or documented constraints)

Tier 6: Production (depends on Tier 5)

setup-monitoring (Tier 5) — 20-60 min
generate-tests (Tier 4) — 30-120 min
  ↓
compliance — 60-120 min
  ├─ Audit security controls
  ├─ Check compliance frameworks (SOC 2, GDPR, HIPAA, etc.)
  ├─ Generate remediation plan
  └─ Create control documentation
  ↓
launch-check — 10-30 min
  ├─ Final pre-flight checklist
  ├─ Verify all systems ready
  ├─ Check documentation complete
  └─ Confirm team ready
  ↓
production-readiness — 30-60 min
  ├─ Final gate: score readiness
  ├─ Block launch if <80% ready
  ├─ Generate readiness report
  └─ Approve for launch
  ↓
LAUNCH

Dependencies:

• compliance requires: Monitoring + security scan
• launch-check requires: Complete scaffold + tests + monitoring + CI/CD
• production-readiness requires: All above complete + compliance pass

Outputs:

• Compliance audit report
• Security remediation plan
• Control implementation checklist
• Launch readiness checklist
• Production readiness score
• Sign-off documentation

Exit criteria:

• ✅ All critical compliance controls addressed
• ✅ >80% test coverage
• ✅ Monitoring in place
• ✅ Disaster recovery plan documented
• ✅ Team trained and ready

Tier 7: Growth (no strict dependency, can run anytime)

Any prior tier complete
  ↓
cost-estimate — 15-30 min
  └─ Estimate infrastructure costs
  
technical-roadmap — 30-45 min
  └─ Plan scaling and feature roadmap
  
user-journeys — 20-30 min
  └─ Map user workflows and pain points
  
user-personas — 20-30 min
  └─ Define target users and characteristics
  
deep-research — 30-60 min
  └─ Market research, competitor analysis
  
mvp-scope — 20-30 min
  └─ Define MVP scope vs. later phases
  
problem-validation — 30-60 min
  └─ Validate market problem
  
generate-docs — 30-90 min
  └─ Generate full documentation suite
  
pitch-deck — 30-60 min
  └─ Generate investor pitch deck
  
hiring-brief — 20-30 min
  └─ Create hiring guide for new team members

Dependencies:

• No strict dependencies
• Can run in any order
• Outputs used for planning, analysis, documentation

Outputs:

• Cost projections
• Roadmap (3-12 months)
• User journey maps
• Persona definitions
• Market research
• MVP/Phase definitions
• Full documentation
• Presentations and slides

Exit criteria:

• ✅ Cost understood
• ✅ Roadmap planned
• ✅ Team aligned on direction

Critical Paths

Path A: Minimum Viable Product (MVP)

blueprint (20 min)
  ↓
design-system (15 min)
  ↓
generate-data-model (20 min)
  ↓
scaffold (45 min)
  ↓
implement (3-7 days)
  ↓
generate-tests (60 min)
  ↓
READY FOR MVP (7-14 days total)

Path B: Launch-Ready (MVP + Observability)

Path A (above) — 7-14 days
  ↓
setup-cicd (25 min)
  ↓
setup-monitoring (40 min)
  ↓
security-scan (30 min)
  ↓
compliance (90 min)
  ↓
launch-check (15 min)
  ↓
production-readiness (45 min)
  ↓
READY FOR PRODUCTION (9-17 days total)

Path C: Enterprise-Ready (All hardening)

Path B (above) — 9-17 days
  ↓
load-test (60 min)
  ↓
accessibility-audit (30 min)
  ↓
technical-roadmap (30 min)
  ↓
disaster-recovery (60 min)
  ↓
READY FOR ENTERPRISE (11-19 days total)

Dependency Rules

Hard Dependencies (blocking)

Some commands cannot start until other commands complete:

scaffold ⚠️  requires design-system + generate-data-model
  └─ Cannot generate code without design tokens or schema

generate-tests ⚠️  requires scaffold
  └─ Cannot test code that doesn't exist

setup-monitoring ⚠️  requires scaffold
  └─ Cannot monitor services that don't exist

production-readiness ⚠️  requires generate-tests + setup-monitoring + compliance
  └─ Cannot launch without safety gates

Soft Dependencies (recommended but not blocking)

Some commands work better with other commands completed, but don't strictly require them:

generate-tests ✓ works better after blueprint
  └─ Can test without blueprint context, but tests are more meaningful with architecture context

cost-estimate ✓ works better after scaffold
  └─ Can estimate based on blueprint alone, but better with actual component count

technical-roadmap ✓ works better after implement
  └─ Can plan without implementation, but roadmap more accurate with progress

Optional Dependencies

Some commands have no dependencies:

blueprint — can run on empty project
sdl — can generate schema from nothing
user-personas — can define without any code
problem-validation — can validate without system

Parallel Execution Opportunities

Some commands can run in parallel (no dependency relationship):

Parallel Safe:
┌─ design-system (15 min)
│
blueprint (20 min) ┤
│
└─ generate-data-model (20 min)

All three can run together, save ~25 minutes vs. sequential
Actual time: max(20, 15, 20) = 20 min instead of 20+15+20 = 55 min

Another parallel opportunity:
┌─ generate-tests (120 min)
│
scaffold (45 min) ┤─ implement (N days)
│
└─ setup-cicd (25 min)

After scaffold completes, tests + cicd can run in parallel during implement

Dependency Matrix

Quick lookup of what each command requires:

Estimated Total Runtimes

By project goal:

Note: Actual time depends heavily on implement duration (days to months).

Using This Graph

For /architect:next-steps

Use the prerequisite graph to:

1. Score commands — give higher scores to unblocked commands in critical path
2. Calculate ETAs — show total time from current state to launch
3. Show blockers — explain why a high-value command is blocked

For /architect:validate-consistency

Use the graph to:

1. Detect cascading failures — if Tier 2 command failed, warn about Tier 3+ being at risk
2. Recommend rerunning prerequisites — if Tier 2 is stale, suggest rerun before Tier 3

For /architect:production-readiness

Use the graph to:

1. Check all required commands complete — verify Path B (Launch-Ready) is done
2. Block launch if gaps — if any Tier 0-6 command missing, fail gate

For Users Planning Work

Use the graph to:

1. Understand sequencing — see which commands must run before others
2. Estimate timeline — pick a critical path and estimate days/hours
3. Identify parallelization — find commands that can run together

Updating the Graph

When a new command is added to the plugin:

1. Identify tier: Where does it fit (foundation, design, code gen, etc.)?
2. List dependencies: What must exist before this command runs?
3. Estimate time: How long does it take (include I/O time)?
4. Update diagram: Add to tier section and dependency matrix
5. Update critical paths: Does this change MVP or launch timelines?

Related Documentation

• /architect:next-steps — uses graph to recommend commands
• /architect:check-state — validates state from completed commands
• /architect:validate-consistency — detects when prerequisites are incomplete
• blocker-detection/SKILL.md — identifies specific blockers
• stage-detection/SKILL.md — uses graph to understand project progression