@schilling.mark.a/software-methodology 1.0.0 → 1.0.1

package/.github/copilot-instructions.md

@@ -97,6 +97,163 @@ continuous-improvement (feeds back to any upstream skill)
 3. Check `/features/*.feature` files for related Gherkin scenarios
 4. Suggest acceptance tests first, then unit tests for edge cases
 
+## Advanced Capabilities
+
+### When asked "What should I do next?" or "What's the next step?"
+
+Analyze the project state by checking for key files, then suggest the appropriate next skill:
+
+1. **No VPC exists** (`/docs/value-proposition-canvas.md` missing)
+   → Suggest creating VPC using `product-strategy/SKILL.md`
+   → Explain: "VPC defines customer jobs, pains, and gains that inform all downstream work"
+
+2. **VPC exists, no story map** (`/docs/story-map/backbone.md` missing)
+   → Suggest creating story map backbone using `story-mapping/SKILL.md`
+   → Explain: "Derive backbone activities from VPC customer jobs"
+
+3. **Story map exists, no feature files** (`/features/` empty or missing)
+   → Suggest writing Gherkin scenarios using `bdd-specification/SKILL.md`
+   → Explain: "Each scenario's 'So that' clause should trace to a VPC gain"
+
+4. **Feature files exist, no tests**
+   → Suggest RED phase using `atdd-workflow/references/red-phase.md`
+   → Explain: "Write failing acceptance test before implementation"
+
+5. **Tests exist and failing**
+   → Suggest GREEN phase using `atdd-workflow/references/green-phase.md`
+   → Explain: "Implement minimum code to pass tests"
+
+6. **Tests passing**
+   → Suggest REFACTOR phase using `atdd-workflow/references/refactor-phase.md` and `clean-code/SKILL.md`
+   → Explain: "Apply SOLID principles while keeping tests green"
+
+7. **Code implemented, no pipeline**
+   → Suggest CI/CD setup using `cicd-pipeline/SKILL.md`
+   → Explain: "Automate build, test, and deployment"
+
+8. **Everything exists**
+   → Suggest continuous improvement using `continuous-improvement/SKILL.md`
+   → Explain: "Measure outcomes, perform root cause analysis, update artifacts"
+
+### When asked to validate Gherkin scenarios
+
+Check the feature file content against `bdd-specification/references/gherkin-patterns.md`:
+
+**Required elements:**
+- Feature declaration with user story (As a... I want... So that...)
+- "So that" clause traces to VPC gain
+- Scenarios use Given-When-Then format
+- Given steps in past tense (establish existing state)
+- When steps in present tense (single user action)
+- Then steps verify observable outcomes (not internal state)
+
+**Common issues to flag:**
+- Missing user story format
+- No VPC traceability in "So that" clause
+- Given steps in future tense
+- Then steps referencing database/logs/internal state (should be user-observable)
+- Multiple scenarios with same structure (suggest Scenario Outline)
+
+**Response format:**
+```
+✅ Validation PASSED / ❌ Validation FAILED
+
+Errors:
+- [List critical issues]
+
+Warnings:
+- [List best practice violations]
+
+Suggestions:
+- [List optimization opportunities]
+
+Reference: bdd-specification/references/gherkin-patterns.md
+```
+
+### When asked to search for guidance on a topic
+
+Search across skills and references for relevant content:
+
+**Process:**
+1. Identify keywords from the question
+2. Check relevant skill SKILL.md files
+3. Check relevant reference documents
+4. Return top 3-5 matches with file paths
+
+**Example queries and where to look:**
+
+- "test before code" / "TDD" / "RED-GREEN-REFACTOR"
+  → `atdd-workflow/SKILL.md`, `atdd-workflow/references/red-phase.md`
+
+- "design patterns" / "SOLID" / "clean code"
+  → `clean-code/SKILL.md`, `clean-code/references/solid.md`, `clean-code/references/*-patterns.md`
+
+- "many parameters" / "object creation"
+  → `clean-code/references/creational-patterns.md` (Builder pattern)
+
+- "hard to test" / "dependencies"
+  → `clean-code/references/solid.md` (Dependency Inversion)
+
+- "Given When Then" / "BDD" / "Gherkin"
+  → `bdd-specification/references/gherkin-patterns.md`
+
+- "deployment" / "CI/CD" / "pipeline"
+  → `cicd-pipeline/SKILL.md`, `cicd-pipeline/references/pipeline-stages.md`
+
+**Response format:**
+```
+# Search Results for '[query]'
+
+1. [skill-name]/[file] (most relevant)
+   [Relevant excerpt from content]
+
+2. [skill-name]/[file]
+   [Relevant excerpt]
+
+3. [skill-name]/[file]
+   [Relevant excerpt]
+```
+
+### When asked about VPC content
+
+Query `/docs/value-proposition-canvas.md` to extract specific information:
+
+**Available segments:**
+- Individual Developer
+- Development Team
+- Engineering Leader / Coach
+
+**Query patterns:**
+
+- "What are the customer segments?" → List all segment names
+- "What are the pains for [segment]?" → Extract pains from that segment's Customer Profile
+- "What are the gains for [segment]?" → Extract gains from that segment's Customer Profile
+- "What are the jobs for [segment]?" → Extract customer jobs from that segment
+- "Search VPC for [term]" → Find pains and gains containing that term across all segments
+
+**Response format:**
+```
+# [Query Title]
+
+## Segment: [Segment Name]
+
+[Relevant pains/gains/jobs numbered list]
+
+Note: Each pain/gain should maintain traceability to downstream artifacts.
+```
+
+### When asked to list skills or references
+
+**List all skills:**
+Provide the 11 skills with brief descriptions from their SKILL.md frontmatter or first paragraph.
+
+**List references for a skill:**
+Check the skill's `references/` directory and list available markdown files.
+
+Example:
+- "What references are available for clean-code?"
+  → List: `solid.md`, `creational-patterns.md`, `structural-patterns.md`, `behavioral-patterns.md`, `enterprise-patterns.md`
+
 ## Important Reminders
 
 - **Always start with business value**: Reference the VPC before suggesting features
@@ -104,3 +261,5 @@ continuous-improvement (feeds back to any upstream skill)
 - **Use ubiquitous language**: Domain terms from `/docs/ubiquitous-language.md`
 - **Patterns over code**: Suggest patterns from `clean-code/references/` before generating code
 - **Incremental delivery**: Align with release plan in `/docs/story-map/releases/`
+- **Project state awareness**: Analyze what exists before suggesting next steps
+- **Traceability**: Every feature should trace from VPC gain → Gherkin scenario → test → code

package/README.md

@@ -1,10 +1,29 @@
 # software-methodology
 
+[![npm version](https://img.shields.io/npm/v/@schilling.mark.a/software-methodology.svg)](https://www.npmjs.com/package/@schilling.mark.a/software-methodology)
+[![npm downloads](https://img.shields.io/npm/dm/@schilling.mark.a/software-methodology.svg)](https://www.npmjs.com/package/@schilling.mark.a/software-methodology)
+
 A comprehensive software development methodology from product strategy through production deployment. Eleven skills, each with a clear scope and a defined position in the chain. Together they form a closed loop: the last skill (continuous-improvement) feeds findings back into any skill upstream.
 
-**Works with:** Claude Code, GitHub Copilot, VS Code, and other AI coding assistants.
+**Works with:** 
+- 🤖 **Claude Desktop** (via MCP server) — Structured tools for querying methodology
+- 🔮 **GitHub Copilot** (via `.github/copilot-instructions.md`) — AI-guided methodology navigation
+- 📝 **VS Code** — Direct markdown file access and workspace navigation
+- 🎯 **Claude Code** — Deployable .skill files for autonomous coding
+- 🛡️ **atdd-guardian** (via git hooks & CI/CD) — Workflow enforcement and validation
+
+**Quick Start:** See [`docs/QUICKSTART.md`](docs/QUICKSTART.md) | **Skills Index:** [`docs/SKILLS.md`](docs/SKILLS.md) | **MCP Server:** [`mcp-server/QUICKSTART.md`](mcp-server/QUICKSTART.md) | **Sharing Guide:** [`docs/SHARING.md`](docs/SHARING.md)
+
+## Installation
+
+```bash
+npm install @schilling.mark.a/software-methodology
+```
 
-**Quick Start:** See [`docs/QUICKSTART.md`](docs/QUICKSTART.md) | **Skills Index:** [`docs/SKILLS.md`](docs/SKILLS.md) | **Sharing Guide:** [`docs/SHARING.md`](docs/SHARING.md)
+Or clone from source:
+```bash
+git clone https://github.com/MarkSchilling/software-methodology.git
+```
 
 ## The Chain
 
@@ -85,15 +104,18 @@ Each skill's `SKILL.md` tells you what to read before starting and what it produ
 
 ### Using with GitHub Copilot / VS Code
 
-**1. Clone or reference this repository.**
+**1. Install the methodology.**
 
-Add this repository as a submodule or reference in your project:
+Choose one of these installation methods:
 
 ```bash
-# As a submodule
+# Option 1: Install via npm (recommended)
+npm install @schilling.mark.a/software-methodology
+
+# Option 2: Add as a submodule
 git submodule add https://github.com/MarkSchilling/software-methodology.git methodology
 
-# Or clone separately
+# Option 3: Clone separately
 git clone https://github.com/MarkSchilling/software-methodology.git
 ```
 
@@ -127,6 +149,150 @@ In VS Code or GitHub, ask Copilot questions like:
 
 Copilot will reference the appropriate skill files and guide you through the process.
 
+### Using with Claude Desktop (MCP Server)
+
+**1. Install the methodology and build the MCP server.**
+
+```bash
+# Option 1: Install via npm (recommended)
+npm install @schilling.mark.a/software-methodology
+cd node_modules/@schilling.mark.a/software-methodology/mcp-server
+npm install
+npm run build
+
+# Option 2: Clone and build from source
+git clone https://github.com/MarkSchilling/software-methodology.git
+cd software-methodology/mcp-server
+npm install
+npm run build
+```
+
+**2. Configure Claude Desktop.**
+
+Edit your Claude Desktop config file:
+
+**macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
+
+Add the MCP server (use the path matching your installation method):
+
+```json
+{
+  "mcpServers": {
+    "software-methodology": {
+      "command": "node",
+      "args": [
+        "/absolute/path/to/node_modules/@schilling.mark.a/software-methodology/mcp-server/dist/index.js"
+      ]
+    }
+  }
+}
+```
+
+**Note:** If you cloned from source, use the path to your clone instead:
+```
+"/absolute/path/to/software-methodology/mcp-server/dist/index.js"
+```
+
+**3. Restart Claude Desktop.**
+
+The MCP server will start automatically and provide structured access to the methodology.
+
+**4. Use the MCP tools.**
+
+In Claude Desktop, ask questions like:
+- "List all available skills"
+- "Show me the SOLID principles"
+- "What are the pains for Individual Developer?"
+- "What should I do next?" (analyzes your project state)
+- "Search for test-first guidance"
+- "Validate this Gherkin scenario" (checks against best practices)
+
+See [`mcp-server/QUICKSTART.md`](mcp-server/QUICKSTART.md) for detailed setup and troubleshooting.
+
+### Using with atdd-guardian (Workflow Enforcement)
+
+**atdd-guardian** is a complementary tool that **enforces** the methodology, while software-methodology MCP **guides** you through it. Think of software-methodology as knowledge and atdd-guardian as guardrails.
+
+**Complementary Roles:**
+
+| Tool | Role | How It Helps |
+|------|------|--------------|
+| **software-methodology MCP** | Knowledge & Guidance | Reads skills, queries VPC, suggests next steps, validates Gherkin syntax |
+| **atdd-guardian** | Workflow Enforcement | Blocks invalid commits, enforces RED-GREEN-REFACTOR, checks test coverage, validates commit messages |
+
+**1. Install atdd-guardian.**
+
+Clone the repository and follow its setup instructions:
+
+```bash
+git clone https://github.com/MarkSchilling/atdd-guardian.git
+cd atdd-guardian
+# Follow installation instructions in atdd-guardian/README.md
+```
+
+**2. Typical workflow using both tools.**
+
+```bash
+# 1. Use software-methodology MCP in Claude Desktop to plan
+#    "What should I do next?"
+#    → Suggests: "Write Gherkin scenario for user login"
+
+# 2. Write the scenario
+vim features/authentication.feature
+
+# 3. Use MCP to validate syntax
+#    "Validate this Gherkin scenario"
+#    → Returns validation feedback
+
+# 4. Try to commit (atdd-guardian enforces RED phase)
+git add features/authentication.feature
+git commit -m "Add login scenario"
+# ✅ Passes: Gherkin scenarios can be committed before tests
+
+# 5. Write failing test (RED phase)
+vim tests/authentication.test.ts
+
+# 6. Try to commit without running tests (atdd-guardian blocks)
+git add tests/authentication.test.ts
+git commit -m "RED: Add login test"
+# ❌ Blocked: "Tests must pass before committing RED phase"
+
+# 7. Run tests, verify failure, commit
+npm test  # Fails as expected
+git commit -m "RED: Add login test - FAILING as expected"
+# ✅ Passes: RED commit with failing test documented
+
+# 8. Implement feature (GREEN phase)
+vim src/auth/login.ts
+
+# 9. Try to commit without tests passing (atdd-guardian blocks)
+git add src/auth/login.ts
+git commit -m "GREEN: Implement login"
+# ❌ Blocked: "Tests must pass in GREEN phase"
+
+# 10. Fix implementation, run tests, commit
+npm test  # Now passes
+git commit -m "GREEN: Implement login - tests passing"
+# ✅ Passes: GREEN commit with passing tests
+
+# 11. Use MCP for refactoring guidance
+#     "Search for guidance on dependency injection"
+#     → Returns clean-code references
+
+# 12. Refactor (atdd-guardian requires tests stay green)
+vim src/auth/login.ts
+npm test  # Must still pass
+git commit -m "REFACTOR: Extract authentication service"
+# ✅ Passes: REFACTOR with tests still passing
+```
+
+**3. How they work together.**
+
+- **software-methodology MCP:** Answers "What should I do?" and "Is this right?" — provides methodology knowledge
+- **atdd-guardian:** Enforces "You must follow the rules" — prevents workflow violations
+
+Both tools reference the same methodology, creating a complete system: one guides you forward, the other prevents you from going backward.
+
 ### General Workflow (All Tools)
 
 1. **Start with product-strategy** — Create Business Model Canvas and Value Proposition Canvas

package/docs/story-map/backbone.md

@@ -0,0 +1,141 @@
+# Story Map Backbone
+
+**Created:** February 16, 2026
+**Last updated:** February 16, 2026
+**Product:** Software Methodology
+
+**Source:** `/docs/value-proposition-canvas.md`
+
+---
+
+## User Activities
+
+### ACT-001: Define Business Value
+**User Goal:** Understand what problem the product solves and for whom
+
+**Value Proposition Link:**
+- Pain relieved: Unclear or changing requirements lead to rework; Disconnect between "what we built" and "what users needed"
+- Gain created: Trace code back to business value; Deliver features users actually want and use
+
+**Reference Skills:** product-strategy
+
+**Tasks:**
+- [ACT-001-task-001](user-tasks/ACT-001-task-001.md): Create Business Model Canvas
+- [ACT-001-task-002](user-tasks/ACT-001-task-002.md): Create Value Proposition Canvas
+
+---
+
+### ACT-002: Understand User Needs
+**User Goal:** Identify who users are, what they need, and how they currently accomplish their goals
+
+**Value Proposition Link:**
+- Pain relieved: Disconnect between built vs needed; No shared language between developers, product, and stakeholders
+- Gain created: Deliver features users actually want; Have clear criteria for "done"
+
+**Reference Skills:** ux-research
+
+**Tasks:**
+- [ACT-002-task-001](user-tasks/ACT-002-task-001.md): Create user personas
+- [ACT-002-task-002](user-tasks/ACT-002-task-002.md): Map user journeys
+- [ACT-002-task-003](user-tasks/ACT-002-task-003.md): Document mental models
+
+---
+
+### ACT-003: Plan Features
+**User Goal:** Organize user activities and tasks into a navigable plan that shows what to build and when
+
+**Value Proposition Link:**
+- Pain relieved: Hard to know what to build first or how to prioritize
+- Gain created: Ship smaller increments more frequently; Have clear criteria for "done" before starting
+
+**Reference Skills:** story-mapping
+
+**Tasks:**
+- [ACT-003-task-001](user-tasks/ACT-003-task-001.md): Create story map backbone
+- [ACT-003-task-002](user-tasks/ACT-003-task-002.md): Define walking skeleton
+- [ACT-003-task-003](user-tasks/ACT-003-task-003.md): Plan release 1
+- [ACT-003-task-004](user-tasks/ACT-003-task-004.md): Break down activities into tasks
+
+---
+
+### ACT-004: Specify Behavior
+**User Goal:** Define expected behavior with concrete examples before writing code
+
+**Value Proposition Link:**
+- Pain relieved: Unclear requirements lead to rework; No shared language between roles
+- Gain created: Have clear criteria for "done" before starting; Establish shared understanding across roles
+
+**Reference Skills:** bdd-specification
+
+**Tasks:**
+- [ACT-004-task-001](user-tasks/ACT-004-task-001.md): Run example mapping session
+- [ACT-004-task-002](user-tasks/ACT-004-task-002.md): Write Gherkin scenarios
+- [ACT-004-task-003](user-tasks/ACT-004-task-003.md): Review scenarios with stakeholders
+
+---
+
+### ACT-005: Design User Experience
+**User Goal:** Design how users interact with the product and ensure it's usable and accessible
+
+**Value Proposition Link:**
+- Pain relieved: Built features don't match what users expected
+- Gain created: Deliver features users actually want; Users can accomplish tasks efficiently
+
+**Reference Skills:** ux-design, ui-design-workflow, ui-design-system
+
+**Tasks:**
+- [ACT-005-task-001](user-tasks/ACT-005-task-001.md): Design information architecture
+- [ACT-005-task-002](user-tasks/ACT-005-task-002.md): Create screen flows
+- [ACT-005-task-003](user-tasks/ACT-005-task-003.md): Select UI components
+- [ACT-005-task-004](user-tasks/ACT-005-task-004.md): Define acceptance targets
+
+---
+
+### ACT-006: Implement Features
+**User Goal:** Write production code that passes acceptance tests and is maintainable
+
+**Value Proposition Link:**
+- Pain relieved: Writing tests after code feels like extra work; Code becomes messy over time
+- Gain created: Feel confident refactoring; Spend less time debugging; Build transferable skills
+
+**Reference Skills:** atdd-workflow, clean-code
+
+**Tasks:**
+- [ACT-006-task-001](user-tasks/ACT-006-task-001.md): Write failing acceptance test (RED)
+- [ACT-006-task-002](user-tasks/ACT-006-task-002.md): Make test pass with minimum code (GREEN)
+- [ACT-006-task-003](user-tasks/ACT-006-task-003.md): Refactor for maintainability
+- [ACT-006-task-004](user-tasks/ACT-006-task-004.md): Review code against SOLID principles
+
+---
+
+### ACT-007: Deploy Safely
+**User Goal:** Ship code to production with confidence and ability to rollback if needed
+
+**Value Proposition Link:**
+- Pain relieved: Fear of breaking existing functionality; Unclear if changes introduced regressions
+- Gain created: Make confident changes; Deploy smaller increments more frequently
+
+**Reference Skills:** cicd-pipeline
+
+**Tasks:**
+- [ACT-007-task-001](user-tasks/ACT-007-task-001.md): Set up pipeline stages
+- [ACT-007-task-002](user-tasks/ACT-007-task-002.md): Configure environment promotion
+- [ACT-007-task-003](user-tasks/ACT-007-task-003.md): Implement deployment strategy
+- [ACT-007-task-004](user-tasks/ACT-007-task-004.md): Test rollback procedure
+
+---
+
+### ACT-008: Measure and Improve
+**User Goal:** Validate that shipped features deliver expected value and identify process improvements
+
+**Value Proposition Link:**
+- Pain relieved: Disconnect between built vs needed; Hard to prove ROI of quality practices
+- Gain created: Demonstrate that quality practices increase delivery speed; Connect engineering to business outcomes
+
+**Reference Skills:** continuous-improvement
+
+**Tasks:**
+- [ACT-008-task-001](user-tasks/ACT-008-task-001.md): Define success metrics
+- [ACT-008-task-002](user-tasks/ACT-008-task-002.md): Collect measurement data
+- [ACT-008-task-003](user-tasks/ACT-008-task-003.md): Perform root cause analysis
+- [ACT-008-task-004](user-tasks/ACT-008-task-004.md): Update upstream artifacts

package/docs/story-map/releases/r1-walking-skeleton.md

@@ -0,0 +1,152 @@
+# Release 1 — Walking Skeleton
+
+**Created:** February 16, 2026
+**Product:** Software Methodology
+
+---
+
+## Goal
+
+Enable a developer to complete their first end-to-end journey through the methodology: from defining business value to deploying working, tested code to production.
+
+---
+
+## Target Date
+
+*To be determined based on implementation approach (tooling, automation, documentation)*
+
+---
+
+## Value Proposition
+
+### Job to be Done
+- Ship working software that delivers business value (Individual Developer)
+- Make confident changes without breaking existing functionality (Individual Developer)
+- Align on what "done" means across team members (Development Team)
+
+### Pain Relieved
+- Unclear or changing requirements lead to rework (30-40% waste)
+- Writing tests after code feels like extra work and is often skipped
+- No shared language between developers, product, and stakeholders
+
+### Gain Created
+- Have clear criteria for "done" before starting work
+- Trace code back to business value
+- Spend less time debugging and more time building
+
+---
+
+## Included Tasks
+
+### ACT-001: Define Business Value
+- ✅ **ACT-001-task-002**: Create Value Proposition Canvas — **Must Have**
+
+### ACT-002: Understand User Needs
+- ❌ All tasks deferred to R2 — Can start with VPC customer jobs alone
+
+### ACT-003: Plan Features
+- ✅ **ACT-003-task-001**: Create story map backbone — **Must Have**
+
+### ACT-004: Specify Behavior
+- ✅ **ACT-004-task-002**: Write Gherkin scenarios — **Must Have**
+
+### ACT-005: Design User Experience
+- ❌ All tasks deferred to R2+ — Not all features require UX design (APIs, CLIs, backend services)
+
+### ACT-006: Implement Features
+- ✅ **ACT-006-task-001**: Write failing acceptance test (RED) — **Must Have**
+- ✅ **ACT-006-task-002**: Make test pass with minimum code (GREEN) — **Must Have**
+- ✅ **ACT-006-task-003**: Refactor for maintainability — **Must Have**
+
+### ACT-007: Deploy Safely
+- ✅ **ACT-007-task-001**: Set up pipeline stages — **Must Have**
+
+### ACT-008: Measure and Improve
+- ❌ All tasks deferred to R3 — Requires multiple delivery cycles to collect meaningful data
+
+---
+
+## Success Metrics
+
+### User Can Complete These Actions
+1. Define business value for a feature using VPC format
+2. Derive 3-5 user activities from VPC customer jobs
+3. Write 2-3 Gherkin scenarios that trace to VPC gains
+4. Write failing acceptance test that verifies one scenario
+5. Implement minimum code to pass the test
+6. Apply one SOLID principle during refactoring
+7. Deploy to production via automated pipeline
+8. Trace deployed code back to original VPC gain
+
+### Measurable Outcomes
+- Time from "feature idea" to "code in production" under 4 hours for simple feature
+- 100% of scenarios have corresponding acceptance tests
+- 100% of production code traces to VPC gain via test → scenario → gain chain
+- Zero manual deployment steps (fully automated pipeline)
+
+---
+
+## Risks
+
+| Risk | Impact | Mitigation |
+|------|--------|-----------|
+| Learning curve too steep for first-time users | High | Provide QUICKSTART.md with worked example; simplify walking skeleton further if needed |
+| Pipeline setup complexity varies by tech stack | Medium | Document common pipeline configurations (GitHub Actions, GitLab CI, Jenkins); focus on principles not specific tools |
+| Developers skip REFACTOR phase under time pressure | High | Make REFACTOR a pipeline gate - code review checks for documented clean code principle application |
+| VPC creation feels abstract without real users | Medium | Provide methodology's own VPC as reference example; emphasize "customer" can include internal users |
+
+---
+
+## Dependencies
+
+### External
+- None - walking skeleton is self-contained and can be completed by individual developer
+
+### Internal Sequencing
+1. VPC must exist before backbone (backbone derives from customer jobs)
+2. Backbone must exist before scenarios (scenarios specify behavior for user tasks)
+3. Scenarios must exist before RED phase (tests verify scenarios)
+4. RED must pass before GREEN (can't make it pass if it doesn't fail first)
+5. GREEN must pass before REFACTOR (can't safely refactor without green tests)
+6. Tests must pass before pipeline deployment (pipeline gates on test success)
+
+---
+
+## What's NOT in Release 1
+
+### Deferred to Release 2
+- UX Research artifacts (personas, journey maps, mental models)
+- Business Model Canvas (VPC sufficient for feature-level work)
+- Example mapping workshops (simplified: write scenarios directly)
+- UI design workflow (add when building UI-heavy features)
+- Comprehensive test strategy documents
+- Walking skeleton document creation (meta-task)
+- Multiple deployment environments and rollback procedures
+
+### Deferred to Release 3
+- Continuous improvement data collection and analysis
+- Root cause analysis procedures
+- Process update feedback loops
+
+### Explicitly Out of Scope
+- Tool-specific implementations (methodology is tool-agnostic)
+- Team working agreements (pairing, mobbing, etc.)
+- Organizational change management
+- Automated validation tooling (CLI, IDE plugins)
+
+---
+
+## Release Narrative
+
+Release 1 proves the methodology works end-to-end with minimum viable implementation of each skill. A developer or team can:
+
+1. **Start with business value** - Define what problem they're solving and for whom (VPC)
+2. **Organize work by user activities** - See the user's journey, not just technical tasks (backbone)
+3. **Specify with examples** - Write concrete, testable scenarios before code (Gherkin)
+4. **Test-first development** - Define "done" before implementation starts (RED-GREEN-REFACTOR)
+5. **Deploy automatically** - Ship to production with confidence (pipeline)
+6. **Trace everything** - Connect any line of code back to business value (VPC → scenario → test → code)
+
+Each subsequent release adds depth: more comprehensive artifacts, additional practices, enhanced tooling support. But Release 1 delivers the complete value loop: idea → value definition → specification → implementation → deployment → verification.
+
+This is the walking skeleton that proves the methodology delivers on its core value proposition: help developers ship working software that solves real problems.