project-iris 0.0.17 → 0.1.0

package/flows/aidlc/README.md

@@ -2,6 +2,8 @@
 
 Welcome to the **AI-DLC (AI-Driven Development Life Cycle)** flow for iris!
 
+---
+
 ## What is AI-DLC?
 
 AI-DLC is an **AWS methodology** for AI-native software development that optimizes for how AI agents work best. Unlike traditional methodologies, AI-DLC:
@@ -11,6 +13,112 @@ AI-DLC is an **AWS methodology** for AI-native software development that optimiz
 - Follows **DDD (Domain-Driven Design)** principles
 - Maintains **persistent context** across sessions through memory bank
 - Operates in **three sequential phases**: Inception → Construction → Operations
+- Supports both **greenfield** (new projects) and **brownfield** (existing codebases) scenarios
+
+---
+
+## Directory Structure
+
+```text
+src/flows/aidlc/
+├── agents/                           # Agent definitions (4 agents)
+│   ├── master-agent.md               # Orchestrator - routes to appropriate agent
+│   ├── inception-agent.md            # Planning phase agent
+│   ├── construction-agent.md         # Building phase agent
+│   └── operations-agent.md           # Deployment phase agent
+│
+├── skills/                           # Agent capabilities (27 skills total)
+│   ├── master/                       # Master Agent skills (6)
+│   │   ├── project-init.md           # Initialize project with standards
+│   │   ├── code-elevate.md           # Brownfield code elevation
+│   │   ├── analyze-context.md        # Analyze current project state
+│   │   ├── route-request.md          # Route to appropriate agent
+│   │   ├── explain-flow.md           # Explain AI-DLC methodology
+│   │   └── answer-question.md        # Answer user questions
+│   │
+│   ├── inception/                    # Inception Agent skills (10)
+│   │   ├── navigator.md              # Navigate inception workflow
+│   │   ├── intent-create.md          # Create new intent with PRFAQ
+│   │   ├── intent-list.md            # List all intents
+│   │   ├── requirements.md           # Gather FR/NFR with measurement criteria
+│   │   ├── risks.md                  # Define and assess risks
+│   │   ├── context.md                # Define system context
+│   │   ├── units.md                  # Decompose into units
+│   │   ├── story-create.md           # Create user stories
+│   │   ├── bolt-plan.md              # Plan bolts for stories
+│   │   └── review.md                 # Review inception artifacts
+│   │
+│   ├── construction/                 # Construction Agent skills (5)
+│   │   ├── navigator.md              # Navigate construction workflow
+│   │   ├── bolt-list.md              # List all bolts
+│   │   ├── bolt-start.md             # Start/continue bolt execution
+│   │   ├── bolt-status.md            # Check bolt progress
+│   │   └── bolt-replan.md            # Replan bolts if needed
+│   │
+│   └── operations/                   # Operations Agent skills (6)
+│       ├── navigator.md              # Navigate operations workflow
+│       ├── build.md                  # Build deployment artifacts
+│       ├── deploy.md                 # Deploy to environment
+│       ├── verify.md                 # Verify deployment
+│       ├── monitor.md                # Setup monitoring and SLOs
+│       └── rollback.md               # Rollback deployment
+│
+├── templates/                        # Artifact templates
+│   ├── inception/                    # Inception phase templates (9)
+│   │   ├── requirements-template.md  # Requirements document
+│   │   ├── prfaq-template.md         # Press Release / FAQ
+│   │   ├── risks-template.md         # Risk assessment
+│   │   ├── system-context-template.md # System context diagram
+│   │   ├── units-template.md         # Unit decomposition overview
+│   │   ├── unit-brief-template.md    # Individual unit brief
+│   │   ├── stories-template.md       # Stories collection
+│   │   ├── story-template.md         # Individual user story
+│   │   └── inception-log-template.md # Inception progress log
+│   │
+│   ├── construction/                 # Construction phase templates
+│   │   ├── bolt-template.md          # Bolt instance metadata
+│   │   ├── construction-guide.md     # Construction workflow guide
+│   │   ├── construction-log-template.md # Construction progress log
+│   │   ├── elevation-static-model-template.md  # Brownfield static model
+│   │   ├── elevation-dynamic-model-template.md # Brownfield dynamic model
+│   │   │
+│   │   ├── bolt-types/               # Bolt type definitions (3 types)
+│   │   │   ├── ddd-construction-bolt.md     # DDD bolt (5 stages)
+│   │   │   ├── simple-construction-bolt.md  # Simple bolt (3 stages)
+│   │   │   ├── spike-bolt.md                # Research/exploration bolt
+│   │   │   └── ddd-construction-bolt/       # DDD stage templates
+│   │   │       ├── ddd-01-domain-design-template.md
+│   │   │       ├── ddd-02-logical-design-template.md
+│   │   │       ├── ddd-03-test-report-template.md
+│   │   │       └── adr-template.md
+│   │   │
+│   │   └── standards/                # Standards templates
+│   │       ├── tech-stack.md
+│   │       ├── coding-standards.md
+│   │       └── system-architecture.md
+│   │
+│   ├── operations/                   # Operations phase templates
+│   │   └── deployment-unit-template.md
+│   │
+│   └── standards/                    # Standards facilitation guides
+│       ├── catalog.yaml              # Standards registry
+│       ├── tech-stack.guide.md       # Tech stack facilitation
+│       ├── coding-standards.guide.md # Coding standards facilitation
+│       └── data-stack.guide.md       # Data stack facilitation
+│
+├── commands/                         # Slash command definitions
+│   ├── iris-master-agent.md          # /iris-master-agent command
+│   ├── iris-inception-agent.md       # /iris-inception-agent command
+│   ├── iris-construction-agent.md    # /iris-construction-agent command
+│   └── iris-operations-agent.md      # /iris-operations-agent command
+│
+├── memory-bank.yaml                  # Memory bank schema (source of truth)
+├── context-config.yaml               # Context loading configuration
+├── quick-start.md                    # Quick start guide
+└── README.md                         # This file
+```
+
+---
 
 ## Three Phases
 
@@ -19,42 +127,44 @@ AI-DLC is an **AWS methodology** for AI-native software development that optimiz
 **Goal**: Complete planning and design before construction begins
 
 **Activities**:
-
-- Gather requirements
-- Create user stories
-- Design architecture
-- Decompose into Units of Work
-- Plan Bolt instances
+- Capture intents (high-level goals)
+- Gather requirements (functional and non-functional)
+- Assess risks (technical, business, operational)
+- Define system context and boundaries
+- Decompose into deployable units
+- Create user stories with acceptance criteria
+- Plan bolts for construction
 
 **Command**: `/iris-inception-agent --intent="intent-name"`
 
-**Output**:
-
-- Requirements documented
-- Stories created
-- Architecture designed
-- Units decomposed
-- Bolts planned
+**Outputs**:
+- PRFAQ document
+- Requirements with measurement criteria
+- Risk assessment
+- System context diagram
+- Unit decomposition
+- User stories
+- Bolt plans
 
 ### 2. Construction Phase
 
 **Goal**: Build working software through iterative bolt execution
 
 **Activities**:
-
 - Execute bolts through DDD stages:
-  1. **domain-design** - Model business logic
-  2. **logical-design** - Apply NFRs and patterns
-  3. **code-generation** - Implement code
-  4. **testing** - Automated testing
+  1. **Domain Design** - Model business logic using DDD principles
+  2. **Logical Design** - Apply NFRs and architectural patterns
+  3. **ADR Analysis** - Document architectural decisions (optional)
+  4. **Code Generation** - Generate production code
+  5. **Testing** - Verify with automated tests
 
 **Command**: `/iris-construction-agent --unit="unit-name"`
 
-**Output**:
-
-- Domain models
-- Logical designs
-- Implementation code
+**Outputs**:
+- Domain design documents
+- Logical design documents
+- Architectural Decision Records (ADRs)
+- Production code with story traceability
 - Comprehensive tests
 
 ### 3. Operations Phase
@@ -62,36 +172,43 @@ AI-DLC is an **AWS methodology** for AI-native software development that optimiz
 **Goal**: Deploy and operate the system
 
 **Activities**:
-
-- Build deployment artifacts
-- Deploy to environments
-- Verify deployments
-- Setup monitoring
+- Build deployment artifacts (containers, functions, bundles)
+- Deploy through environments (Dev → Staging → Production)
+- Verify deployments with health checks
+- Setup monitoring, alerts, and SLOs
+- Handle rollbacks when needed
 
 **Command**: `/iris-operations-agent --unit="unit-name"`
 
-**Output**:
-
-- Deployed services
+**Outputs**:
+- Deployment units
 - Monitoring dashboards
+- Alert configurations
+- Runbooks/playbooks
 - Deployment documentation
 
-## Artifact Ownership Matrix
+---
 
-| Phase / Agent | Primary Output Artifacts | Description |
-|--------------|-------------------------|-------------|
-| **Inception** | **Requirements** | Functional & Non-functional requirements |
-| | **Stories** | User stories scoped to a Unit |
-| | **System Context** | High-level boundaries & actors |
-| | **Unit Decomposition** | Identification of independent units |
-| | **Bolt Plans** | Planned work sessions |
-| **Construction** | **Domain Design** | Entities, Aggregates, Value Objects |
-| | **Logical Design** | APIs, Schemas, Cloud Resources |
-| | **Code** | Source code implementation |
-| | **Tests** | Unit, Integration, & E2E tests |
-| **Operations** | **Build Artifacts** | Docker images, binaries, bundles |
-| | **Infrastructure** | Terraform/CloudFormation/CDK |
-| | **Documentation** | Runbooks, API docs |
+## Project Scenarios
+
+### Greenfield (New Projects)
+Starting fresh with no existing code:
+1. Initialize project with standards
+2. Begin Inception phase immediately
+3. Build from scratch using AI-DLC methodology
+
+### Brownfield (Existing Codebases)
+Adding features to existing code:
+1. Initialize project with standards
+2. **Run code elevation** to analyze existing codebase
+3. AI creates static and dynamic models for context
+4. Begin Inception with full codebase understanding
+
+**Code Elevation Process**:
+- **Static Model**: Components, responsibilities, and relationships
+- **Dynamic Model**: How components interact for significant use cases
+
+---
 
 ## Decomposition Hierarchy
 
@@ -110,7 +227,6 @@ Intent (feature/capability)
 **Bolts** are time-boxed execution sessions scoped to a **Unit**. A Unit may require multiple Bolts to complete all its Stories.
 
 **Example**:
-
 - **Intent**: User Authentication
   - **Unit**: Auth Service
     - **Story 1**: User Registration
@@ -118,255 +234,283 @@ Intent (feature/capability)
     - **Bolt 1**: Implement Registration (executes Story 1)
     - **Bolt 2**: Implement Login (executes Story 2)
 
-## Agent Capabilities & Slash Commands
+---
+
+## Artifact Ownership Matrix
+
+| Phase / Agent | Primary Output Artifacts | Description |
+|--------------|-------------------------|-------------|
+| **Master** | **project.yaml** | Project configuration and scenario |
+| | **standards/** | Tech stack, coding standards, architecture |
+| | **elevation/** | Static and dynamic models (brownfield) |
+| **Inception** | **requirements.md** | Functional & non-functional requirements |
+| | **prfaq.md** | Press Release / FAQ document |
+| | **risks.md** | Risk assessment with mitigations |
+| | **system-context.md** | High-level boundaries & actors |
+| | **units.md** | Unit decomposition overview |
+| | **stories/** | User stories scoped to units |
+| | **bolt plans** | Planned work sessions |
+| **Construction** | **domain-design.md** | Entities, Aggregates, Value Objects |
+| | **logical-design.md** | APIs, Schemas, Cloud Resources |
+| | **adr-*.md** | Architectural Decision Records |
+| | **test-report.md** | Test results and coverage |
+| | **Source Code** | Production code implementation |
+| **Operations** | **deployment-units/** | Packaged artifacts documentation |
+| | **playbooks/** | Incident response runbooks |
+| | **Monitoring** | Dashboards, alerts, SLOs |
+
+---
 
-### Core Agent Commands (Slash Commands)
+## Agent Commands & Skills
 
-These are the primary entry points defined in `.cursor/commands` (or your agentic coding tool's equivalent), mapping to `src/flows/aidlc/commands/`:
+### Master Agent (`/iris-master-agent`)
 
-- `/iris-master-agent` - **Start Here**. The Master Orchestrator that routes you to the right place.
-- `/iris-inception-agent` - Start Inception phase
-- `/iris-construction-agent` - Start Construction phase
-- `/iris-operations-agent` - Start Operations phase
+The central orchestrator and entry point.
 
-### Agent Skills (Internal)
+| Skill | Purpose |
+|-------|---------|
+| `project-init` | Initialize project with standards |
+| `code-elevate` | Analyze existing codebase (brownfield) |
+| `analyze-context` | View current project state |
+| `route-request` | Get directed to the right agent |
+| `explain-flow` | Learn about AI-DLC methodology |
+| `answer-question` | Get help with any iris question |
 
-Agents execute these skills internally. You generally don't run these directly as slash commands, but the agents use them to perform work.
+### Inception Agent (`/iris-inception-agent --intent="name"`)
 
-- **Inception**: Gather Requirements, Create Stories, Define Context, Decompose Units
-- **Construction**: Plan Bolts, Start Bolts, Manage Bolt Status
-- **Operations**: Build, Deploy, Verify
+Handles the planning phase.
 
-## Memory Bank Structure
+| Skill | Purpose |
+|-------|---------|
+| `navigator` | Navigate inception workflow |
+| `intent-create` | Create a new intent with PRFAQ |
+| `intent-list` | List all intents |
+| `requirements` | Gather requirements with measurements |
+| `risks` | Assess risks (likelihood, impact, mitigations) |
+| `context` | Define system context |
+| `units` | Decompose into units |
+| `story-create` | Create stories for a unit |
+| `bolt-plan` | Plan bolts for stories |
+| `review` | Review inception artifacts |
+
+### Construction Agent (`/iris-construction-agent --unit="name"`)
+
+Handles the building phase.
 
-> **Note**: The structure below is an **example**. The authoritative source of truth for the memory bank schema is `.iris/aidlc/memory-bank.yaml`. Agents read that file to determine where to place artifacts.
+| Skill | Purpose |
+|-------|---------|
+| `navigator` | Navigate construction workflow |
+| `bolt-list` | List all bolts with status |
+| `bolt-start` | Start/continue executing a bolt |
+| `bolt-status` | Check bolt progress |
+| `bolt-replan` | Replan bolts if needed |
 
-All artifacts are stored in the `memory-bank/` directory:
+### Operations Agent (`/iris-operations-agent --unit="name"`)
+
+Handles the deployment phase.
+
+| Skill | Purpose |
+|-------|---------|
+| `navigator` | Navigate operations workflow |
+| `build` | Build deployment artifacts |
+| `deploy` | Deploy to environment |
+| `verify` | Verify deployment |
+| `monitor` | Set up monitoring and SLOs |
+| `rollback` | Rollback to previous version |
+
+---
+
+## Bolt Types
+
+| Type | Best For | Stages |
+|------|----------|--------|
+| **DDD Construction** | Complex business logic, domain modeling | Domain Design → Logical Design → ADR (optional) → Code Generation → Testing |
+| **Simple Construction** | UI, integrations, utilities | Plan → Code Generation → Testing |
+| **Spike** | Research, exploration, unknowns | Research → Document → Recommend |
+
+---
+
+## Memory Bank Structure
+
+All artifacts are stored in `memory-bank/` (schema defined in `memory-bank.yaml`):
 
 ```text
 memory-bank/
+├── project.yaml                      # Project configuration
+│
+├── elevation/                        # Brownfield code analysis
+│   ├── static-model.md               # Components, responsibilities, relationships
+│   └── dynamic-model.md              # Use case interactions
+│
 ├── intents/                          # Feature intents
-│   └── {intent-name}/
+│   └── {NNN}-{intent-name}/
 │       ├── requirements.md           # Functional & non-functional requirements
-│       ├── system-context.md         # High-level boundaries & actors
+│       ├── prfaq.md                  # Press Release / FAQ
+│       ├── risks.md                  # Risk assessment
+│       ├── system-context.md         # System boundaries & actors
 │       ├── units.md                  # Unit decomposition overview
 │       └── units/
-│           └── {unit-name}/
+│           └── {UUU}-{unit-name}/
 │               ├── unit-brief.md     # Unit scope and details
 │               └── stories/
 │                   ├── 001-{title}.md
 │                   └── 002-{title}.md
+│
 ├── bolts/                            # Bolt execution records
-│   └── {bolt-id}/
+│   └── {BBB}-{unit-name}/
 │       ├── bolt.md                   # Bolt instance metadata
-│       ├── ddd-01-domain-model.md    # Stage 1: Domain modeling
-│       ├── ddd-02-technical-design.md # Stage 2: Technical design
+│       ├── ddd-01-domain-design.md   # Stage 1: Domain design
+│       ├── ddd-02-logical-design.md  # Stage 2: Logical design
+│       ├── adr-{N}-{slug}.md         # Stage 3: ADR (optional)
 │       └── ddd-03-test-report.md     # Stage 5: Test report
+│
 ├── standards/                        # Project standards
 │   ├── tech-stack.md
 │   ├── coding-standards.md
-│   └── system-architecture.md
+│   ├── system-architecture.md
+│   ├── api-conventions.md
+│   └── ux-guide.md
+│
 └── operations/                       # Deployment context
+    ├── deployment-units/
+    │   └── {unit-name}.md
+    └── playbooks/
+        ├── high-error-rate.md
+        ├── high-latency.md
+        └── service-down.md
 ```
 
-## Quick Start Guide
-
-### 1. Create Your First Intent
-
-Open your AI coding tool (Claude Code, Cursor, etc.) and type:
-
-```text
-/iris-master-agent
-```
-
-Then type `intent-create` to create your intent (e.g., "user-authentication").
-
-### 2. Run Inception Phase
-
-```text
-/iris-inception-agent --intent="user-authentication"
-```
-
-Work through the Inception menu:
-
-1. Gather Requirements
-2. Create Stories
-3. Design Architecture
-4. Decompose into Units
-5. Plan Bolts
-6. Review & Complete
-
-### 3. Execute Construction
-
-```text
-/iris-construction-agent --unit="auth-service"
-```
-
-Start your first bolt and work through the DDD stages:
-
-1. Domain Design
-2. Logical Design
-3. Code Generation
-4. Testing
-
-### 4. Deploy with Operations
-
-```text
-/iris-operations-agent --unit="auth-service"
-```
-
-Deploy your unit:
-
-1. Build Deployment Artifacts
-2. Deploy to Environment
-3. Verify Deployment
-4. Setup Monitoring
+---
 
 ## Key Principles
 
-### 1. Mob Elaboration (Rapid Planning)
-
-AI-DLC uses **concentrated rapid planning** during Inception. Instead of distributing planning across multiple sprints, you complete all planning in hours (not weeks) to give AI complete cross-unit context.
-
-### 2. AI Plans, Human Validates
-
-The AI suggests decompositions and designs, but humans review and approve all decisions.
+### 1. AI Drives, Human Validates
+AI proposes plans, decompositions, and implementations. Humans review and approve at checkpoints.
 
-### 3. Bolts are Flexible
+### 2. Human Oversight as Loss Function
+Validation at each step catches errors early before they cascade downstream.
 
-Bolts take "hours or days" depending on complexity - they're not fixed-duration like sprints.
+### 3. Mob Elaboration
+Concentrated rapid planning during Inception. Complete all planning in hours, not weeks.
 
-### 4. DDD Focus
+### 4. Bolts are Flexible
+Bolts take "hours or days" depending on complexity - not fixed-duration like sprints.
 
-Domain-Driven Design principles guide the entire Construction phase.
-
-### 5. Persistent Context
+### 5. DDD Focus
+Domain-Driven Design principles guide the Construction phase with proper separation of concerns.
 
+### 6. Persistent Context
 Everything is stored in the memory bank so context is never lost between sessions.
 
+---
+
 ## Workflow Example
 
 Here's a complete workflow for building a feature:
 
-1. **Create Intent**
-
-   ```text
-   /iris-master-agent
-   # Then type: intent-create
-   # Create "user-authentication" intent
-   ```
+### 1. Initialize Project
 
-2. **Inception Phase**
-
-   ```text
-   /iris-inception-agent --intent="user-authentication"
-   # Complete all inception activities
-   # Result: 2 units planned with 3 bolts total
-   ```
+```text
+/iris-master-agent
+# Then type: project-init
+# Set up tech stack and coding standards
+```
 
-3. **Construction - Unit 1**
+### 2. Create Intent (Inception Phase)
 
-   ```text
-   /iris-construction-agent --unit="auth-service"
-   # Execute auth-service-bolt-1 through all stages
-   # Execute auth-service-bolt-2 through all stages
-   # Result: Auth service fully implemented and tested
-   ```
+```text
+/iris-inception-agent --intent="user-authentication"
+# Work through:
+# - requirements (FR/NFR)
+# - risks
+# - context
+# - units
+# - stories
+# - bolt-plan
+# - review
+```
 
-4. **Construction - Unit 2**
+### 3. Execute Bolts (Construction Phase)
 
-   ```text
-   /iris-construction-agent --unit="email-service"
-   # Execute email-service-bolt-1
-   # Result: Email service implemented
-   ```
+```text
+/iris-construction-agent --unit="auth-service"
+# Execute each bolt through stages:
+# 1. Domain Design
+# 2. Logical Design
+# 3. ADR Analysis (optional)
+# 4. Code Generation
+# 5. Testing
+```
 
-5. **Operations**
+### 4. Deploy (Operations Phase)
 
-   ```text
-   /iris-operations-agent --unit="auth-service"
-   # Build, deploy, verify
-   # Result: Auth service running in production
+```text
+/iris-operations-agent --unit="auth-service"
+# - build
+# - deploy (Dev → Staging → Production)
+# - verify
+# - monitor
+```
 
-   /iris-operations-agent --unit="email-service"
-   # Build, deploy, verify
-   # Result: Email service running in production
-   ```
+---
 
 ## Tips for Success
 
-### Planning
-
-- Be thorough in Inception - it pays off during Construction
-- Document NFRs clearly - they affect logical design
+### Planning (Inception)
+- Be thorough - it pays off during Construction
+- Document NFRs with measurable criteria
+- Assess risks early with mitigations
 - Group related stories into the same bolt
 
-### Construction
-
+### Building (Construction)
 - Follow the DDD stages in order
 - Don't skip testing
 - Keep bolts focused (5-8 stories max)
-- Update memory bank artifacts as you progress
-
-### Operations
+- Document significant decisions as ADRs
 
+### Deploying (Operations)
 - Always deploy to staging first
 - Run smoke tests after every deployment
 - Setup monitoring from the start
 - Document runbooks for on-call engineers
 
-## Agents
-
-Three specialized agents guide you through AI-DLC:
-
-1. **Master Orchestrator** (`agents/master-agent.md`)
-   - Central entry point
-   - Workflow routing
-   - State analysis
+---
 
-2. **Inception Agent** (`agents/inception-agent.md`)
-   - Requirements gathering
-   - Story creation
-   - Architecture design
-   - System Context definition
-   - Unit decomposition
-   - Bolt planning
+## Getting Help
 
-3. **Construction Agent** (`agents/construction-agent.md`)
-   - Bolt execution
-   - DDD stage guidance
-   - Code generation
-   - Testing
+If you get stuck:
 
-4. **Operations Agent** (`agents/operations-agent.md`)
-   - Build artifacts
-   - Deployment
-   - Verification
-   - Monitoring
+1. **Ask the Agent**: Just ask the Master or any agent your question. They can read the memory bank directly.
 
-## Learn More
+2. **Explain Flow**: Type `explain-flow` with the Master Agent to learn about AI-DLC methodology.
 
-- **Official AI-DLC Documentation**: See `/resource/aidlc-pdf-dump.txt` in the iris repository
-- **Methodology Notes**: See `memory-bank/research/` for methodology research
-- **Agent Details**: Read the agent files in `.iris/aidlc/agents/`
+3. **Answer Question**: Type `answer-question` followed by your question.
 
-## Getting Help
+4. **Quick Start Guide**: See `quick-start.md` in this directory.
 
-If you get stuck:
+5. **Glossary**: See `memory-bank/glossary.md` for terminology.
 
-1. **Ask the Agent**: Just ask the Master or any agent your question. They can read the memory bank directly.
+---
 
 ## Customization
 
 You can customize this flow by editing:
 
-- `.iris/aidlc/memory-bank.yaml` - Memory bank structure
+- `memory-bank.yaml` - Memory bank structure
 - `agents/*-agent.md` - Agent directives and behaviors
+- `skills/**/*.md` - Skill implementations
+- `templates/**/*.md` - Artifact templates
 - `commands/*.md` - Slash command definitions
-- `.iris/aidlc/templates/` - Templates used by agents
 
 ---
 
-**Happy building with AI-DLC!** 🚀
+## Learn More
+
+- **Quick Start Guide**: `quick-start.md`
+- **Glossary**: `memory-bank/glossary.md`
+- **AI-DLC Specification**: `/resources/ai-dlc-specification.md`
+- **Agent Details**: `agents/` directory
+
+---
 
 *This is the official AI-DLC implementation by iris, following the AWS AI-DLC methodology.*