SuperAPI AI Directory

pm-method-story-mapping

General & other

View repository

Updated 10-16 09:55

About this skill

"User Story Mapping" · First draw the skeleton of the entire journey, then slice across to the smallest usable version

When to use me

  • A pile of requirements but the whole picture can't be explained clearly, and the PRD looks like a flat list → use [Story Map Skeleton]
  • Need to define the MVP / what to slice for the first release → use [Cross-Slice Release Slices]
  • The team has inconsistent understanding of "what to do" → use [Shared Understanding Over Documentation]
  • Not suitable for: judging whether requirements are real (see pm-method-mom-test), judging whether something should be done (see pm-advisor-cagan / build-trap). This book addresses "once it's decided to do it, how to structure and slice the expression".

Core Frameworks

Framework 1: Story Map Skeleton (The Map, Chapters 2, 5)

Applicable scenario: organize scattered requirements into a whole that can be understood at a glance.

Steps:

  1. Along the timeline of "the user doing this from start to finish", lay out the big activities horizontally (backbone) → e.g.: register → find product → place order → receive goods
  2. Under each activity, expand specific tasks vertically (user tasks), arranged downward by detail
  3. Read from left to right once = a complete story, check for breaks/gaps
  4. Output: a two-dimensional map (horizontal axis = narrative sequence of the process, vertical axis = priority/detail)

Framework 2: Cross-Slice Release Slices (Slicing Releases, Chapters 5, 6)

Applicable scenario: define what each release version does, especially the first version.

Steps:

  1. Draw a line horizontally across the map, slicing out the thinnest layer that "spans all activities and can run through" → walking skeleton
  2. The first version takes only the single most core task in each activity, ensuring end-to-end usability, rather than perfecting a certain module
  3. Each subsequent version adds a layer downward along the map, gradually enriching it
  4. Output: a map layered by release slices, each layer being a deliverable, verifiable complete experience

Framework 3: Shared Understanding Over Documentation (Shared Understanding, Chapter 1 & opening "The Word Is Not the Thing")

Applicable scenario: cross-team alignment on "what exactly we want to do".

Steps:

  1. Don't expect documents to automatically convey understanding—stories are "meant to prompt conversation", not written down to check off
  2. Draw the map together (PM + design + engineering), exposing disagreements and reaching consensus during the drawing process
  3. After the map is drawn, the value left behind is "the consistent picture in everyone's head"; the document is just a memo
  4. Output: a collaborative session of building the map together + a map serving as an anchor for conversation

Decision Rules (with source annotations)

  1. If your requirements are a vertical flat list, then rearrange it into a two-dimensional map of "horizontal process + vertical detail". (Chapter 5)
  2. If you need to define the MVP, then slice a walking skeleton horizontally, letting it run through end to end, rather than vertically completing a certain module. (Chapters 5, 6)
  3. If you have written many story documents but never discussed them together, then you do not have shared understanding—the purpose of stories is conversation. (Chapter 1)
  4. If a story is too large to finish in a few weeks (an epic), then split it along the map into small slices that can be delivered independently. (Chapter 13)
  5. If the team is arguing about "which module to do first," then go back to the map and ask "which thinnest end-to-end slice can validate value fastest." (Chapter 6)
  6. User stories are written as "As a <who>, I want <what>, so that <what value is gained>," with the emphasis on the why at the end. (Chapter 15 / Connextra template)
  7. If you are focused only on the features being output, then add a step: "what change do we want to happen in user behavior/business outcomes" (outcomes take priority over a delivery checklist). (Chapter 3)

Checklist: a healthy story map (synthesizing Chapters 5 and 6)

  • There is a backbone that reads from left to right (a complete user journey)
  • The vertical axis is ordered by priority; the higher up, the more necessary
  • The first release slice is cross-cutting and usable end to end (not a perfect version of some module)
  • Each slice corresponds to a complete experience that can be delivered and validated
  • Large stories (epics) have been split down to what can be completed within one iteration
  • The map is drawn by the team together, not written alone by the PM and then presented
  • Each card can spark conversation, rather than being executed only as a spec

Anti-patterns (explicitly warned about in the book)

  1. Flat backlog—a long vertical list that does not reveal the whole picture or allow release slicing. (Chapter 5)
  2. Treating writing stories as writing detailed specs—assuming that if the text is detailed enough, conversation can be skipped, and understanding is still lost. (Chapter 1)
  3. Vertical MVP slicing—making some module perfect while it does not work end to end, so users cannot use it when they get it. (Chapter 6)
  4. Only the PM builds the map/writes stories—losing the greatest value of stories (shared understanding). (Chapter 1)
  5. Pursuing "writing all stories completely" rather than "making clear the first version to be built"—details should unfold only as development approaches. (Chapter 14)

Boundary statement

  • Published in 2014, the method is stable; it addresses "how to structure and slice what has already been decided to build," not "whether it should be built/whether the requirement is real"
  • Applicable to: decomposition and release planning of product features with clear user flows; for work such as pure algorithms/infrastructure with no clear user journey, the map form needs adaptation
  • It assumes the team can collaborate on building the map; for remote/asynchronous teams or teams with unequal voice, "shared understanding" needs additional mechanisms to guarantee it
  • If terminology details differ when distilled from secondhand sources, the original book prevails

Workflow

After receiving a user question:

  1. Match the scenario → choose a framework (build the backbone / slice releases / align understanding)
  2. Missing core inputs (target users, the main flow of this matter) → list the information that needs to be supplied all at once; for missing secondary information, fill it in marked with [assumption]
  3. Execute according to the framework steps: help the user arrange scattered requirements into a backbone + tasks, and cross-cut the first version
  4. Review the result with the "healthy map checklist," marking items that do not pass (especially "whether the first version is cross-cutting and end to end")
  5. State the boundaries at the end, and suggest cross-validating from another perspective (e.g., "whether this version should be built, ask pm-advisor-cagan's four big risks")

This Skill was generated by career-skill-factory. The content is distilled from the original work, copyright belongs to the original author Jeff Patton, and it is for personal learning only.