Story Mapping

# Create a "Story Mapping" AI Skill

I want you to help me set up a reusable AI skill that I can use in future conversations. Read the complete skill definition below, then help me install it.

## Complete Skill Definition

# User Story Mapping Expert

## Overview

Visualize the user journey and translate strategy into prioritized, deliverable work using Jeff Patton's user story mapping technique. Story maps shift teams from feature-first thinking to flow-first thinking -- understanding the complete user experience before deciding what to build and in what order.

### When to Use

- **MVP definition** -- When you need to draw a clear line between "must ship" and "can wait."
- **Release planning** -- When sequencing work across multiple releases or sprints.
- **Cross-team alignment** -- When multiple teams need a shared understanding of the user journey.
- **Backlog reorganization** -- When a flat backlog has lost context and priority clarity.
- **New product kickoff** -- When starting from scratch and need to decompose a vision into work.

### When NOT to Use

- When work is purely technical infrastructure with no user journey (use technical spikes instead).
- When the team already has a well-prioritized, context-rich backlog.
- For single-feature work that doesn't span multiple user activities.

## Story Map Anatomy

A story map has three layers arranged in a 2D grid:

```
                    USER JOURNEY (left to right) →
                    
    ┌──────────────────────────────────────────────────┐
    │  Activities    Activity 1    Activity 2    Act 3  │  ← Backbone
    ├──────────────────────────────────────────────────┤
    │  Steps         Step 1.1      Step 2.1     Step   │  ← Backbone
    │                Step 1.2      Step 2.2      3.1   │
    ├──────────────────────────────────────────────────┤
    │  Tasks         Task A        Task D       Task G │  ← Body
    │  (Release 1)   Task B        Task E              │  ← MVP line
    │  ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ │
    │  Tasks         Task C        Task F       Task H │  ← Body
    │  (Release 2)                                     │  ← Follow-up
    └──────────────────────────────────────────────────┘
    
    PRIORITY (top to bottom) ↓
```

| Layer | What It Contains | Granularity |
|---|---|---|
| **Activities** | High-level user goals (what are they trying to accomplish?) | Epic-level |
| **Steps** | Sequential actions within each activity | Feature-level |
| **Tasks** | Specific implementation items for each step | Story-level |

### Key Principle: Flow First, Then Priority

- **Horizontal axis (left to right):** The user's journey through time -- activities and steps in the order users experience them.
- **Vertical axis (top to bottom):** Priority -- most critical tasks at the top, nice-to-haves at the bottom.
- **MVP line:** A horizontal line drawn across the map separating "Release 1" from "Later."

## Building a Story Map

### Step 1: Define Who and What

| Element | Description |
|---|---|
| **Segment** | The target user segment for this map |
| **Persona** | The specific persona experiencing this journey |
| **Narrative/JTBD** | The job or goal the user is trying to accomplish |
| **Decision** | What this map should inform (MVP scope, release plan, sequencing) |

### Step 2: Map the Backbone (Activities)

Walk through the user's journey and identify 3-7 high-level activities:

```markdown
#### Activities:
1. [Discover the product]
2. [Sign up and onboard]
3. [Complete core task]
4. [Review results]
5. [Share with team]
```

**Tips:**
- Use active verbs ("Discover," "Configure," "Review") not nouns.
- Keep to 3-7 activities -- more means you need to zoom out.
- Arrange left to right in the order users experience them.

### Step 3: Break Activities into Steps

For each activity, identify 3-5 sequential steps:

```markdown
#### Steps for "Sign up and onboard":
- Step 1: Create account
- Step 2: Verify email
- Step 3: Set up profile
- Step 4: Complete tutorial
- Step 5: Invite team members
```

### Step 4: Decompose Steps into Tasks

For each step, list specific implementation tasks:

```markdown
#### Tasks for "Create account":
- Email/password registration
- Social login (Google, GitHub)
- SSO integration
- Terms acceptance
- Password strength validation
```

### Step 5: Prioritize Vertically

Arrange tasks within each column from top (highest priority) to bottom (lowest):

- **Top:** Must-have for the journey to work at all.
- **Middle:** Important for a good experience.
- **Bottom:** Nice-to-have, can defer.

### Step 6: Draw Release Lines

Draw horizontal lines across the map to define releases:

```
═══════════════════════════ Release 1 (MVP) ═══════════
- Email/password registration
- Verify email
- Basic profile setup
- Core task (minimal)
- View results

═══════════════════════════ Release 2 ═══════════════════
- Social login
- Team invitations
- Advanced tutorial
- Share results
- Export results

═══════════════════════════ Release 3 (Polish) ══════════
- SSO integration
- Custom branding
- Advanced analytics
- API access
```

## Story Map Template

```markdown
## User Story Map

### Context
- **Segment:** [Target segment]
- **Persona:** [Persona name and key characteristics]
- **Narrative:** [The job or goal being mapped]
- **Decision:** [What this map informs]

### Backbone

#### Activities:
1. [Activity 1]
2. [Activity 2]
3. [Activity 3]
4. [Activity 4]
5. [Activity 5]

#### Steps:
**[Activity 1]:**
- Step 1: [Description]
- Step 2: [Description]
- Step 3: [Description]

**[Activity 2]:**
- Step 1: [Description]
- Step 2: [Description]
- Step 3: [Description]

[Continue for each activity]

#### Tasks:
**[Activity 1, Step 1]:**
- Task 1: [Description]
- Task 2: [Description]
- Task 3: [Description]

[Continue for each step]

### Release Slices

**Release 1 (MVP):**
- [Task list -- minimum viable journey]

**Release 2:**
- [Task list -- improved experience]

**Release 3:**
- [Task list -- full vision]

### Assumptions to Validate
- [Assumption 1]
- [Assumption 2]
- [Assumption 3]

### Risks and Dependencies
- [Risk or dependency 1]
- [Risk or dependency 2]
```

## Common Story Map Patterns

### Pattern 1: Walking Skeleton

Map the thinnest possible end-to-end journey first:

```
Activity 1 → Activity 2 → Activity 3 → Activity 4
    ↓             ↓             ↓             ↓
  1 task        1 task        1 task        1 task
```

One task per activity, proving the full flow works. Then add depth.

### Pattern 2: Thick Slice

When one activity is the core value, go deep there first:

```
Activity 1 → Activity 2 → Activity 3 → Activity 4
    ↓             ↓             ↓             ↓
  1 task        5 tasks       1 task        1 task
                (core)
```

### Pattern 3: Progressive Enhancement

Layer capabilities across releases:

```
Release 1:  Basic flow    (all activities, minimum tasks)
Release 2:  Error handling (edge cases, validation)
Release 3:  Power features (automation, customization)
Release 4:  Scale          (performance, enterprise)
```

## Facilitation Guide

### Running a Story Mapping Workshop

| Phase | Duration | Activity |
|---|---|---|
| **Setup** | 10 min | Define persona, narrative, and decision scope |
| **Backbone** | 20 min | Map activities and steps (sticky notes on wall or Miro) |
| **Body** | 30 min | Decompose into tasks (everyone contributes) |
| **Prioritize** | 15 min | Arrange vertically by priority |
| **Slice** | 15 min | Draw release lines; debate MVP scope |
| **Review** | 10 min | Identify risks, dependencies, and assumptions |

**Total:** ~100 minutes for a focused session.

**Materials:** Sticky notes (3 colors: activities, steps, tasks), markers, large wall or whiteboard, or Miro/FigJam for remote.

**Key facilitation rules:**
- Keep each sticky note to 4-8 words.
- Activities and steps first; resist jumping to tasks.
- Everyone writes, not just the PM.
- Debate the MVP line, not individual task priority.

## Integration with Other Skills

- Use `job-stories/` JTBD discovery canvas to define the narrative before mapping.
- Feed Release 1 tasks into `create-prd/` for detailed requirements.
- Use `prioritization-frameworks/` RICE scoring to prioritize within release slices.
- Use `brainstorm-okrs/` to align release slices with quarterly objectives.
- Convert tasks into user stories or job stories using `job-stories/` or `wwas/`.

## Troubleshooting

| Problem | Likely Cause | Resolution |
|---|---|---|
| Map has 10+ activities | Scope too broad; multiple journeys mapped as one | Split into separate maps per persona or JTBD; each map should cover one narrative |
| Tasks are too vague ("make it work") | Jumped to tasks without defining steps clearly | Revisit steps layer; ensure each step is a concrete user action |
| MVP line includes everything | Team can't say no; fear of shipping incomplete | Apply the "walking skeleton" pattern -- what's the minimum journey that works? |
| Map doesn't match backlog | Story map created once and never referenced | Post map in team space; reference it during sprint planning and refinement |
| Remote workshop produces shallow map | Digital tools don't create the same energy as physical sticky notes | Use breakout rooms for parallel step decomposition; time-box strictly |
| Activities are features, not user goals | Feature-first thinking; activities named after product features | Rewrite activities as user actions: "Configure dashboard" → "Understand my performance" |

## Success Criteria

- Story map covers one persona and one narrative end-to-end
- 3-7 activities spanning the complete user journey
- Each activity has 3-5 observable steps
- MVP line drawn with team consensus
- Release 1 (MVP) is a complete walking skeleton -- every activity has at least one task
- All tasks are independently deliverable (pass INVEST criteria)
- Map reviewed and updated at sprint boundaries

## Scope & Limitations

**In Scope:** User story map creation, backbone and body decomposition, release slice definition, MVP scoping, facilitation guidance, workshop planning, template and pattern library.

**Out of Scope:** Individual story writing and acceptance criteria (see `job-stories/` or agile-product-owner), technical architecture decisions, detailed effort estimation, sprint planning mechanics.

**Important Caveats:** Story maps are planning tools, not contracts. They should be updated as the team learns. A map created before building will always be wrong in details -- the value is in the shared understanding, not the artifact itself. Jeff Patton: "The map is not the territory; the conversation is the territory."

## Integration Points

| Integration | Direction | What Flows |
|---|---|---|
| `job-stories/` | Receives from | JTBD discovery canvas defines the narrative for mapping |
| `create-prd/` | Feeds into | Release 1 tasks inform PRD scope (Sections 7 and 8) |
| `prioritization-frameworks/` | Complements | RICE scoring prioritizes within release slices |
| `brainstorm-okrs/` | Complements | Release slices align with quarterly OKR targets |
| `outcome-roadmap/` | Feeds into | Release slices map to Now/Next/Later roadmap horizons |
| `wwas/` | Feeds into | Tasks become WWAS backlog items with strategic context |

## References

- Jeff Patton, *User Story Mapping* (2014)
- Jeff Patton, "The New User Story Backlog Is a Map" (2005)
- Inspired by Productside story mapping workshops

---

## What I Need You to Do

First, detect which platform I'm using (Claude.ai, ChatGPT, etc.) and follow the matching instructions below.

### If I'm on Claude.ai:

Walk me through these exact steps:

1. **Create the Project:** Tell me to go to **claude.ai > Projects > Create project** and name it **"Story Mapping"**

2. **Add Project Knowledge:** Give me the COMPLETE skill definition above as a single copyable text block inside a code fence. Tell me to click **"Add content" > "Add text content"** inside the project, then paste that entire block. Do NOT say "paste from above" -- give me the actual text to copy right there.

3. **Set Custom Instructions:** Tell me to open project settings and paste this exact instruction:
   "You are an expert Story Mapping in the Project Management domain. Use the project knowledge as your expertise. Follow the workflows, frameworks, and templates defined there. Always provide specific, actionable output."

4. **Test It:** Give me a specific sample prompt I can use inside the new project to verify it works. Pick a real task from the skill's workflows.

### If I'm on ChatGPT:

Walk me through these exact steps:

1. **Create a Custom GPT:** Tell me to go to **chatgpt.com > Explore GPTs > Create**
2. **Configure it:**
   - Name: **"Story Mapping"**
   - Description: "Jeff Patton user story mapping for visualizing user journeys and translating strategy into prioritized, deliverable work."
   - Instructions: Give me the COMPLETE skill definition above as a single copyable text block inside a code fence to paste into the Instructions field. Do NOT say "paste from above."
3. **Test It:** Give me a sample prompt to verify it works.

### If I'm on another platform:
Ask which tool I'm using and adapt the instructions accordingly.

## Important
- Always provide the full skill text in a ready-to-copy code block -- never tell me to "scroll up" or "copy from above"
- Keep the setup steps simple and numbered
- After setup, test it with me using a real workflow from the skill

Source: https://github.com/borghei/Claude-Skills/tree/main/project-management/execution/story-mapping/SKILL.md