project-iris 0.0.1

package/src/iris_bundle/frameworks/iris-core/docs.iris.md/compare/vs-bmad.mdx

@@ -0,0 +1,167 @@
+---
+title: "specs.md vs BMAD-Method"
+description: "Compare specs.md with BMAD's multi-agent framework"
+---
+
+## Overview
+
+Both **specs.md (AI-DLC)** and **BMAD-Method** target complex systems and enterprise-scale development. The key difference is their approach to agent organization.
+
+**BMAD-Method** uses 19+ role-based agents that simulate a full development team (Analyst, PM, Architect, Developer, QA, etc.).
+
+**specs.md (AI-DLC)** uses 3 phase-based agents aligned to AI-DLC's methodology (Inception, Construction, Operations).
+
+---
+
+## Side-by-Side Comparison
+
+| Aspect | specs.md | BMAD |
+|--------|-------------------|------|
+| **Target Complexity** | Complex systems (same tier) | Complex/Enterprise systems (same tier) |
+| **Origin** | AWS formal methodology | Community-driven framework |
+| **Agent Philosophy** | 3 phase-based agents | 19+ role-based agents |
+| **Agents** | Master, Inception, Construction, Operations | Analyst, PM, Architect, Dev, QA, UX, etc. |
+| **Methodology** | AI-DLC (AWS standard) | Agentic Agile (open source) |
+| **Design Technique** | DDD integrated as core | Optional, team choice |
+| **Rituals** | Mob Elaboration, Mob Construction (collocated) | Agent handoffs (async) |
+| **Iteration** | Bolts ("hours or days") | Epics/Stories |
+| **Complexity** | Moderate | High |
+| **Customization** | Skills + Templates | Full persona customization via YAML |
+| **Community** | Just born (December 2025) | 26k+ GitHub stars |
+| **VS Code Extension** | Yes ([visual dashboard](/getting-started/vscode-extension)) | No |
+
+---
+
+## When to Choose Each
+
+<CardGroup cols={2}>
+  <Card title="Choose specs.md (AI-DLC) if:" icon="check">
+    - You want a formal AWS methodology
+    - You prefer fewer, phase-aligned agents
+    - You want DDD as an integral part (not optional)
+    - You value collocated Mob rituals
+    - You want to avoid managing 19 agents
+    - You want a [VS Code extension](/getting-started/vscode-extension) to track progress visually
+  </Card>
+  <Card title="Choose BMAD if:" icon="check">
+    - You want maximum agent customization
+    - You prefer role-based agent simulation
+    - You're comfortable with higher complexity
+    - You want 19+ specialized personas
+    - You prefer async agent handoffs
+    - You have time to invest in learning
+  </Card>
+</CardGroup>
+
+---
+
+## Key Differences
+
+### 1. Agent Organization
+
+**BMAD**: Focuses on traditional Agile roles—19+ agents mimicking a full development team with familiar titles.
+
+```
+Analyst Agent → PM Agent → Architect Agent →
+Product Owner Agent → Scrum Master Agent →
+Developer Agent → QA Agent → ...
+```
+
+**specs.md (AI-DLC)**: Focuses on AI development lifecycle phases with shorter iterations (Bolts, not sprints). 3 agents aligned to process phases.
+
+```
+Inception Agent → Construction Agent → Operations Agent
+```
+
+### 2. Methodology Foundation
+
+**BMAD**: "Breakthrough Method for Agile AI-Driven Development" - an open source framework built on agile principles with AI agents replacing human roles.
+
+**specs.md**: AWS's formally defined AI-DLC methodology with specific phases, rituals, and artifacts documented in a whitepaper.
+
+### 3. Design Technique Integration
+
+**BMAD**: Design techniques are optional. Teams can choose their own approach.
+
+**specs.md**: DDD is integrated as core. AI applies domain-driven design principles during decomposition—it's not optional.
+
+### 4. Rituals and Collaboration
+
+**BMAD**: Agents hand off documents to each other asynchronously.
+
+**specs.md**: Mob Elaboration and Mob Construction are collocated rituals where teams work together with AI in real-time.
+
+---
+
+## Agent Mapping
+
+If you're familiar with BMAD agents, here's how they map to AI-DLC:
+
+| BMAD Agents | specs.md Phase |
+|-------------|------------------------|
+| Analyst, PM | **Inception Agent** - requirements elaboration |
+| Architect | **Inception Agent** + **Construction Agent** - domain modeling |
+| Product Owner, Scrum Master | **Master Agent** - orchestration |
+| Developer, QA | **Construction Agent** - code generation, testing |
+| DevOps | **Operations Agent** - deployment |
+
+---
+
+## Complexity vs Control Trade-off
+
+```mermaid
+graph LR
+    subgraph Simplicity
+        SM[specs.md<br/>3 agents]
+    end
+    subgraph Complexity
+        BM[BMAD<br/>19+ agents]
+    end
+
+    SM --> |"More agents<br/>More control"| BM
+    BM --> |"Fewer agents<br/>Simpler mental model"| SM
+
+    style SM fill:#34D399,stroke:#10B981,color:#fff
+    style BM fill:#8B5CF6,stroke:#7C3AED,color:#fff
+```
+
+---
+
+## Migration Path
+
+If you're currently using BMAD and want to try AI-DLC:
+
+<Steps>
+  <Step title="Map Your Agents">
+    Understand how your 19 agents map to 3 AI-DLC phases
+  </Step>
+  <Step title="Adopt Mob Rituals">
+    Replace async handoffs with collocated Mob Elaboration and Mob Construction
+  </Step>
+  <Step title="Integrate DDD">
+    Move from optional design techniques to DDD as core
+  </Step>
+  <Step title="Use Phase-Based Thinking">
+    Organize work by phase (Inception → Construction → Operations) rather than role
+  </Step>
+</Steps>
+
+---
+
+## Summary
+
+| For This Need | Use This |
+|---------------|----------|
+| Formal AWS methodology | specs.md |
+| Maximum agent customization | BMAD |
+| Simpler mental model (3 agents) | specs.md |
+| Role-based simulation (19+ agents) | BMAD |
+| DDD as core requirement | specs.md |
+| Collocated Mob rituals | specs.md |
+| Async agent handoffs | BMAD |
+
+<Info>
+**Bottom Line**: Both target complex systems. specs.md offers a formal methodology with 3 phase-based agents. BMAD offers maximum customization with 19+ role-based agents.
+
+*Choose based on whether you prefer methodology-driven simplicity or agent-driven flexibility.*
+</Info>

package/src/iris_bundle/frameworks/iris-core/docs.iris.md/compare/vs-kiro.mdx

@@ -0,0 +1,208 @@
+---
+title: "specs.md vs Kiro (AWS)"
+description: "Compare specs.md with AWS Kiro IDE"
+---
+
+## Overview
+
+**Kiro** is AWS's agentic IDE built on Code OSS (VS Code foundation) with integrated spec-driven development, agent hooks, and deep AWS integration. **To use Kiro's spec-driven features, you must use their paid IDE**—there's no way to use the methodology with your preferred tools.
+
+**specs.md** is an IDE-agnostic framework implementing AWS's AI-DLC methodology. It works with 11+ AI coding tools including Claude Code, Cursor, GitHub Copilot, Windsurf, and more. Your specs and agents are portable markdown files—no vendor lock-in.
+
+<Info>
+**Coming Soon**: specs.md (Simple Flow) will provide Kiro-style Requirements → Design → Tasks workflow.
+</Info>
+
+---
+
+## Side-by-Side Comparison
+
+| Aspect | specs.md | Kiro |
+|--------|-------------------|------|
+| **Type** | Framework/CLI | Full IDE |
+| **IDE** | Works with any (Cursor, VS Code, Claude Code, etc.) | Kiro IDE only |
+| **Workflow** | AI-DLC: Inception → Construction → Operations | Requirements → Design → Tasks |
+| **Methodology** | Formal AI-DLC phases and rituals | Kiro SDD workflow |
+| **Automation** | Skills + Templates | Agent Hooks + Steering |
+| **Context** | Memory Bank (persistent project knowledge) | requirements.md, design.md, tasks.md + steering files |
+| **AI Model** | Any (Claude, GPT, Gemini, etc.) | Claude Sonnet 4.5 + Auto mode |
+| **Pricing** | Free (open source) | Free preview → $20/mo (Pro), $39/mo (Pro+), $200/mo (Power) |
+| **Spec Format** | Markdown + YAML | EARS notation for requirements |
+| **Lock-in** | None | Kiro IDE + Claude only |
+| **VS Code Extension** | Yes ([visual dashboard](/getting-started/vscode-extension)) | Built into IDE (limited) |
+| **Maturity** | Production-ready | Preview (July 2025) |
+
+---
+
+## When to Choose Each
+
+<CardGroup cols={2}>
+  <Card title="Choose specs.md (AI-DLC) if:" icon="check">
+    - You want IDE flexibility (not locked to Kiro)
+    - You prefer AI-DLC's formal 3-phase methodology
+    - You want to use your preferred AI model
+    - You want to use free AI tools (Copilot, Cline, Kilo Code, etc.)
+    - You need Mob rituals for team collaboration
+    - You want DDD as an integral part
+    - You want a [VS Code extension](/getting-started/vscode-extension) to track progress visually
+  </Card>
+  <Card title="Choose Kiro if:" icon="check">
+    - You want an all-in-one IDE experience
+    - You're heavily invested in AWS ecosystem
+    - You want built-in agent hooks for automation
+    - You prefer visual spec generation
+    - You're okay with Claude Sonnet only
+    - You're okay with subscription pricing
+  </Card>
+</CardGroup>
+
+---
+
+## Key Differences
+
+### 1. IDE Lock-in (Paid)
+
+**Kiro**: Requires Kiro IDE subscription ($19-39/month) to use spec-driven features. You cannot use Kiro's methodology in VS Code, Cursor, or other editors.
+
+**specs.md**: Works with **11+ tools** including Claude Code, Cursor, GitHub Copilot, Windsurf, Cline, Roo, Gemini CLI, Codex CLI, OpenCode, and more. Your specs are portable markdown files—switch tools anytime.
+
+### 2. AI Model Flexibility
+
+**Kiro**: Uses Claude Sonnet 4.5 with an "Auto" mode that mixes frontier models. No option to use GPT, Gemini, or bring your own API key.
+
+**specs.md**: Works with any AI model. Use whichever model works best for your use case.
+
+### 3. Pricing Model
+
+**Kiro** (revised August 2025):
+- Free: 50 vibe requests (no spec requests)
+- Pro: $20/month (225 vibe, 125 spec requests)
+- Pro+: $39/month (450 vibe, 250 spec requests)
+- Power: $200/month (2,250 vibe, 1,250 spec requests)
+
+**specs.md**:
+- Free (open source)
+- Pay only for your AI API tokens
+
+### 4. Context Management
+
+**Kiro** uses simple spec files + steering:
+```
+.kiro/
+├── requirements.md   # Requirements spec
+├── design.md         # Design spec
+├── tasks.md          # Task breakdown
+└── steering/         # Agent steering files
+```
+
+**specs.md** uses Memory Bank:
+```
+memory-bank/
+├── context-config.yaml    # Phase-aware context
+├── artifacts/             # Persistent artifacts
+└── standards/             # Project standards
+```
+
+### 5. Automation Approach
+
+**Kiro** uses Agent Hooks (event-driven):
+```yaml
+# .kiro/hooks/update-tests.yaml
+trigger: on_save
+pattern: "**/*.tsx"
+action: "Update related test file"
+```
+
+**specs.md** uses Skills and Templates:
+```yaml
+# skills/construction/domain-modeling.yaml
+name: Domain Modeling
+triggers:
+  - bolt-start
+  - domain-design
+actions:
+  - Apply DDD principles
+  - Generate component model
+```
+
+<Info>
+**Coming Soon**: specs.md (Simple Flow) will provide Kiro-style Requirements → Design → Tasks workflow.
+</Info>
+
+---
+
+## Feature Comparison
+
+### Kiro's Unique Features
+
+| Feature | Description |
+|---------|-------------|
+| **EARS Notation** | Structured requirements format |
+| **Agent Hooks** | Event-driven automations on file save/create |
+| **MCP Integration** | Connect external tools via Model Context Protocol |
+| **Autopilot Mode** | AI works autonomously on foundational tasks |
+| **AWS Powers** | One-click AWS service integrations |
+
+### specs.md Unique Features
+
+| Feature | Description |
+|---------|-------------|
+| **Mob Rituals** | Collocated team collaboration with AI |
+| **DDD as Core** | Domain-driven design integrated, not optional |
+| **Phase-Based Agents** | 3 agents aligned to AI-DLC phases |
+| **Bolts** | Rapid iteration cycles (hours/days, not weeks) |
+| **IDE Freedom** | Works with any IDE and AI model |
+| **[VS Code Extension](/getting-started/vscode-extension)** | Visual dashboard for tracking bolts, specs, and progress |
+
+---
+
+## Cost Comparison
+
+| Tool | Cost |
+|------|------|
+| specs.md | $0 + API tokens |
+| Kiro Pro | $20/month (225 vibe + 125 spec/mo) |
+| Kiro Pro+ | $39/month (450 vibe + 250 spec/mo) |
+| Kiro Power | $200/month (2,250 vibe + 1,250 spec/mo) |
+
+---
+
+## Migration Path
+
+If you're using Kiro and want more methodology structure:
+
+<Steps>
+  <Step title="Export Kiro Specs">
+    Convert Kiro's requirements.md, design.md, tasks.md to specs.md Memory Bank format
+  </Step>
+  <Step title="Map Hooks to Skills">
+    Convert agent hooks to specs.md skills (or wait for Simple Flow with hook support)
+  </Step>
+  <Step title="Adopt AI-DLC Phases">
+    Organize work into Inception, Construction, Operations
+  </Step>
+  <Step title="Add Mob Rituals">
+    Introduce Mob Elaboration and Mob Construction for team alignment
+  </Step>
+</Steps>
+
+---
+
+## Summary
+
+| For This Need | Use This |
+|---------------|----------|
+| IDE flexibility | specs.md |
+| All-in-one IDE | Kiro |
+| AI model choice | specs.md |
+| AWS deep integration | Kiro |
+| Free/open source | specs.md |
+| Built-in agent hooks | Kiro (or wait for specs.md Simple Flow) |
+| Formal methodology | specs.md |
+| Mob rituals | specs.md |
+
+<Info>
+**Bottom Line**: Kiro offers a polished, all-in-one experience with AWS integration. specs.md offers methodology depth, IDE freedom, and no subscription costs.
+
+*Want Kiro's simplicity with AI-DLC's methodology? Wait for specs.md (Simple Flow).*
+</Info>

package/src/iris_bundle/frameworks/iris-core/docs.iris.md/compare/vs-openspec.mdx

@@ -0,0 +1,140 @@
+---
+title: "specs.md vs OpenSpec"
+description: "Compare specs.md with OpenSpec's change-centric approach"
+---
+
+## Overview
+
+**OpenSpec** is a lightweight, brownfield-first CLI tool focused on change management. It separates current truth (`specs/`) from proposed changes (`changes/`).
+
+**specs.md** is a full lifecycle methodology covering Inception through Operations, with support for both greenfield and brownfield development.
+
+---
+
+## Side-by-Side Comparison
+
+| Aspect | specs.md | OpenSpec |
+|--------|-------------------|----------|
+| **Primary Focus** | Full lifecycle (Inception → Operations) | Change management |
+| **Best For** | Greenfield + brownfield | Greenfield + brownfield (brownfield-focused) |
+| **Philosophy** | Complete methodology | Lightweight, change-centric |
+| **Structure** | Intents → Units → Stories | Specs + Changes separation |
+| **Brownfield Support** | Supported (with model elevation) | Excellent (primary design focus) |
+| **Token Efficiency** | Both (Units scope context) | Both (spec deltas) |
+| **Design Integration** | DDD as core | Design-agnostic (your choice) |
+| **Rituals** | Mob Elaboration, Mob Construction | None |
+| **Learning Curve** | Moderate | Low |
+| **VS Code Extension** | Yes ([visual dashboard](/getting-started/vscode-extension)) | CLI dashboard |
+
+---
+
+## When to Choose Each
+
+<CardGroup cols={2}>
+  <Card title="Choose specs.md (AI-DLC) if:" icon="check">
+    - You need full project lifecycle support
+    - You're building new features (greenfield)
+    - You want DDD integration
+    - You need Mob rituals for team alignment
+    - You want formal methodology structure
+    - You want a [VS Code extension](/getting-started/vscode-extension) to track progress visually
+  </Card>
+  <Card title="Choose OpenSpec if:" icon="check">
+    - You primarily make incremental changes
+    - You're working with existing codebases
+    - You want maximum token efficiency
+    - You prefer minimal overhead
+    - You want the simplest possible setup
+    - You make high-volume, small-scope changes
+  </Card>
+</CardGroup>
+
+---
+
+## Key Differences
+
+### 1. Design Philosophy
+
+**OpenSpec**: Brownfield-first. Designed for modifying existing systems with a clear separation between current state and proposed changes.
+
+```
+openspec/
+├── specs/      # Current truth (what exists)
+└── changes/    # Proposed updates (what's changing)
+```
+
+**specs.md**: Full lifecycle. Designed for complex systems from inception through operations.
+
+```
+memory-bank/
+├── intents/           # High-level goals
+├── units/             # Decomposed work
+├── construction/      # Domain models, code
+└── operations/        # Deployment, monitoring
+```
+
+### 2. Token Efficiency
+
+**OpenSpec**: Excellent token efficiency. Only sends "spec deltas" (proposed changes) to the LLM, not the full codebase context.
+
+**specs.md**: Memory Bank provides structured context. You can achieve similar change-focused efficiency by creating Units specifically for changes—keeping context scoped to what matters.
+
+| Approach | Token Usage | Best For |
+|----------|-------------|----------|
+| OpenSpec | Lower | High-volume small changes |
+| specs.md | Higher | Complex decisions requiring full context |
+
+### 3. Brownfield Handling
+
+**OpenSpec**: Primary design focus. Every change is explicit with clear before/after separation.
+
+**specs.md**: Supported via "model elevation" - AI first converts existing code to semantic models (domain components, relationships) before making changes. *More advanced brownfield process coming soon.*
+
+```
+AI-DLC Brownfield Flow:
+Existing Code → Semantic Models → Changes → Updated Code
+```
+
+### 4. Methodology vs Tool
+
+**OpenSpec**: A tool for managing specs and changes. No prescribed methodology.
+
+**specs.md**: A complete methodology with:
+- Defined phases (Inception → Construction → Operations)
+- Rituals (Mob Elaboration, Mob Construction)
+- Design integration (DDD as core)
+- Role definitions (AI drives, human validates)
+
+---
+
+## Use Case Comparison
+
+| Use Case | OpenSpec | specs.md |
+|----------|----------|-------------------|
+| Small bug fix | Excellent | Overkill |
+| Feature tweak | Excellent | Good |
+| New feature (existing codebase) | Good | Excellent |
+| New system (greenfield) | Limited | Excellent |
+| Complex refactoring | Good | Excellent |
+| Multi-team coordination | Limited | Excellent |
+
+---
+
+## Summary
+
+| For This Need | Use This |
+|---------------|----------|
+| Brownfield changes | OpenSpec (excellent) or specs.md (good) |
+| Greenfield development | specs.md |
+| Token efficiency | Both |
+| Full lifecycle | specs.md |
+| Minimal setup | OpenSpec |
+| DDD integration | specs.md |
+| Team rituals | specs.md |
+| High-volume small changes | OpenSpec |
+
+<Info>
+**Bottom Line**: OpenSpec excels at brownfield changes with minimal overhead. specs.md provides full lifecycle support for complex systems.
+
+*For brownfield work within a larger project, consider using both together.*
+</Info>

package/src/iris_bundle/frameworks/iris-core/docs.iris.md/compare/vs-speckit.mdx

@@ -0,0 +1,146 @@
+---
+title: "specs.md vs GitHub Spec Kit"
+description: "Compare specs.md with GitHub's Spec Kit toolkit"
+---
+
+## Overview
+
+**GitHub Spec Kit** is a toolkit that provides agent prompts and 7 slash commands (`/speckit.constitution`, `/speckit.specify`, `/speckit.plan`, `/speckit.tasks`, `/speckit.analyze`, `/speckit.implement`, `/speckit.clarify`) for 15+ AI coding assistants including Claude Code, Cursor, GitHub Copilot, and Gemini CLI.
+
+**specs.md** is a full methodology implementation with phase-based agents, Mob rituals, and DDD integration.
+
+<Info>
+**Coming Soon**: specs.md (Simple Flow) will provide Spec Kit-like simple flows for teams wanting a lighter entry point.
+</Info>
+
+---
+
+## Side-by-Side Comparison
+
+| Aspect | specs.md | Spec Kit |
+|--------|-------------------|----------|
+| **Type** | Full methodology | Toolkit + Agent Prompts |
+| **Target** | Complex systems requiring trade-offs | Small-medium projects |
+| **Approach** | Structured AI-DLC phases with methodology | 6-phase workflow with agent prompts |
+| **Structure** | Intents → Units → Stories | Constitution → Specify → Plan → Tasks → Analyze → Implement |
+| **Agent Model** | 3 phase-based agents | Prompts for 15+ AI assistants |
+| **Design Integration** | DDD default (extensible via bolt types) | Constitution file |
+| **Rituals** | Mob Elaboration, Mob Construction | None |
+| **Memory** | Memory Bank (persistent context) | Constitution file + .specify folder |
+| **Customization** | Skills, templates, memory bank | Constitution file, scripts, templates |
+| **Learning Curve** | Moderate | Low |
+| **VS Code Extension** | Yes ([visual dashboard](/getting-started/vscode-extension)) | No |
+
+---
+
+## When to Choose Each
+
+<CardGroup cols={2}>
+  <Card title="Choose specs.md (AI-DLC) if:" icon="check">
+    - You're building complex systems with architectural trade-offs
+    - You need DDD integration and domain modeling
+    - You want Mob rituals for team alignment
+    - You have multiple teams needing coordination
+    - You want a proven AWS methodology
+    - You want a [VS Code extension](/getting-started/vscode-extension) to track progress visually
+  </Card>
+  <Card title="Choose Spec Kit if:" icon="check">
+    - You want minimal workflow change
+    - You're working on simpler projects
+    - You prefer command-driven interaction
+    - You want the lowest learning curve
+    - You're a solo developer or small team
+  </Card>
+</CardGroup>
+
+---
+
+## Key Differences
+
+### 1. Methodology vs Toolkit
+
+**Spec Kit** is a toolkit—a set of commands that structure your prompts. It doesn't prescribe how you work, just helps you write better specs.
+
+**specs.md** is a full methodology with:
+- Defined phases (Inception → Construction → Operations)
+- Rituals (Mob Elaboration, Mob Construction)
+- Role definitions (AI drives, human validates)
+- Artifact specifications (Intents, Units, Bolts)
+
+### 2. Conversation Direction
+
+**Spec Kit**: Agent-driven via structured prompts
+```
+Human: /speckit.specify [high-level description]
+AI: [generates detailed specification with user journeys]
+AI: [asks clarifying questions via /speckit.clarify]
+Human: [validates and refines]
+```
+
+**specs.md**: AI drives with Mob rituals
+```
+Human: [provides intent]
+AI: "I've analyzed your intent. Here are 3 Units I propose.
+     I have 5 clarifying questions before we proceed..."
+Human: [validates, approves, or redirects in Mob session]
+```
+
+### 3. Design Integration
+
+**Spec Kit**: Constitution file sets project principles and constraints. Technical plan phase handles architecture decisions.
+
+**specs.md**: DDD is the default methodology. AI applies domain-driven design principles during decomposition, creating bounded contexts, aggregates, and domain models. Extensible via bolt types for BDD, TDD, or custom flows.
+
+---
+
+## AI-DLC's Opinionated Approach
+
+Unlike toolkit-based approaches, AI-DLC is an opinionated methodology with specific patterns:
+
+**Bolts, Not Sprints**: Instead of 2-week sprints with variable scope, AI-DLC uses Bolts—focused execution units measured in hours or days. Each Bolt batches related stories together and executes them with full DDD construction steps.
+
+**DDD Baked In**: Domain-Driven Design isn't optional—it's integral. Every Bolt follows DDD patterns: domain modeling, bounded contexts, aggregates, and entities. This creates consistent, high-quality designs regardless of who's working.
+
+**Agent Drives, Human Validates**: In AI-DLC, the AI proposes breakdown, trade-offs, and designs. Humans validate and approve. This reversed conversation direction keeps humans in control while leveraging AI's synthesis capabilities.
+
+**Full Traceability**: Artifacts created during construction show exactly what was built and how—from Intent to Unit to Story to Bolt execution.
+
+---
+
+## Migration Path
+
+If you're currently using Spec Kit and want more structure:
+
+<Steps>
+  <Step title="Start with Simple Flow (Coming Soon)">
+    specs.md (Simple Flow) will provide Kiro-style Requirements → Design → Tasks workflow
+  </Step>
+  <Step title="Add Memory Bank">
+    Enable persistent context across sessions
+  </Step>
+  <Step title="Adopt Phase Structure">
+    Organize work into Inception, Construction, Operations
+  </Step>
+  <Step title="Graduate to Full AI-DLC">
+    When complexity demands it, adopt full Mob rituals and DDD integration
+  </Step>
+</Steps>
+
+---
+
+## Summary
+
+| For This Need | Use This |
+|---------------|----------|
+| Quick spec generation | Spec Kit or specs.md (Simple Flow) |
+| Minimal learning curve | Spec Kit |
+| Complex system development | specs.md |
+| Team coordination | specs.md |
+| Enterprise/regulated environments | specs.md |
+| DDD integration | specs.md |
+
+<Info>
+**Bottom Line**: Spec Kit is great for adding light structure. specs.md is for when you need a complete methodology for complex systems.
+
+*Can't decide? Wait for specs.md (Simple Flow)—start simple, graduate when needed.*
+</Info>