navraj007in/skills/prerequisite-graph

Prerequisite Graph Skill

Documents the complete dependency graph of all 54 /architect: commands, 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:

| Tier | Commands | ETA | Depends on | |------|----------|-----|-----------| | Tier 0: Foundation | blueprint, sdl, import | 20-30 min | Nothing (can start empty) | | Tier 1: Design & Schema | design-system, generate-data-model | 15-30 min | Tier 0 complete | | Tier 2: Code Generation | scaffold, scaffold-component | 15-60 min | Tier 0, Tier 1 | | Tier 3: Development | implement, review, visualise | 30 min - days | Tier 2 complete | | Tier 4: Quality | generate-tests, security-scan | 30-120 min | Tier 3 complete | | Tier 5: Scale | load-test, setup-cicd, setup-monitoring | 20-120 min | Tier 2 + Tier 4 | | Tier 6: Production | compliance, launch-check, production-readiness | 60-180 min | Tier 5 complete | | Tier 7: Growth | cost-estimate, technical-roadmap, etc. | 15-45 min | Any tier (no strict dependency) |

---

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:

| Command | Requires | Optional | Tier | |---------|----------|----------|------| | blueprint | — | problem-validation | 0 | | sdl | — | blueprint | 0 | | import | existing codebase | — | 0 | | problem-validation | — | — | 0 | | design-system | blueprint | — | 1 | | generate-data-model | SDL entities | — | 1 | | user-personas | — | problem-validation | 1 | | deep-research | — | — | 7 | | mvp-scope | blueprint | — | 7 | | scaffold | blueprint, design-system, generate-data-model | — | 2 | | scaffold-component | scaffold | — | 2 | | implement | scaffold | blueprint | 3 | | visualise | blueprint, scaffold | — | 3 | | review | scaffold, code | — | 3 | | generate-tests | scaffold | blueprint | 4 | | security-scan | scaffold | — | 4 | | accessibility-audit | scaffold | — | 4 | | setup-cicd | scaffold | — | 5 | | setup-monitoring | scaffold | — | 5 | | load-test | scaffold | — | 5 | | compliance | scaffold | security-scan | 6 | | launch-check | scaffold, tests, monitoring | — | 6 | | production-readiness | tests, monitoring, compliance | — | 6 | | cost-estimate | blueprint | scaffold | 7 | | technical-roadmap | blueprint | — | 7 | | user-journeys | — | mvp-scope | 7 | | pitch-deck | — | user-personas | 7 | | wireframes | design-system | — | 7 | | prototype | scaffold | design-system | 7 | | prototype-iterate | prototype | — | 7 | | sync-backlog | — | — | 7 | | agent-spec | — | — | 7 | | check-env | scaffold | — | 7 | | publish-api-docs | scaffold | contracts | 7 | | validate-consistency | — (any project state) | — | 7 | | next-steps | — (any project state) | — | 7 | | check-state | — (any project state) | — | 7 | | launch-checklist | blueprint | — | 7 | | onboarding-pack | — | — | 7 | | hiring-brief | blueprint | — | 7 | | compare-stack | — | — | 7 | | complexity-check | blueprint | — | 7 | | well-architected | blueprint | — | 7 | | database-scaling | generate-data-model | — | 7 | | seo | scaffold | — | 7 | | analytics-setup | scaffold | — | 7 | | disaster-recovery | production-readiness | setup-monitoring | 6 | | i18n-setup | scaffold | — | 7 | | setup-env | scaffold | — | 7 | | export-diagrams | visualise | — | 7 | | quick-spec | — | — | 7 | | sprint-status | — (in-conversation) | — | 7 |

---

Estimated Total Runtimes

By project goal:

| Goal | Critical Path | Total Time | Commands | |------|---|---|---| | Concept Phase | problem-validation | 30 min | 1-2 | | MVP Ready | Tier 0-3 | 7-14 days | 5-7 | | Launchable | Tier 0-6 | 9-17 days | 10-14 | | Enterprise-Ready | Tier 0-7 | 11-20 days | 20-25 | | Full Scope | All 54 commands | 30-60 days | 54 |

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