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:
- 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
- Under each activity, expand specific tasks vertically (user tasks), arranged downward by detail
- Read from left to right once = a complete story, check for breaks/gaps
- 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:
- Draw a line horizontally across the map, slicing out the thinnest layer that "spans all activities and can run through" → walking skeleton
- The first version takes only the single most core task in each activity, ensuring end-to-end usability, rather than perfecting a certain module
- Each subsequent version adds a layer downward along the map, gradually enriching it
- 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:
- Don't expect documents to automatically convey understanding—stories are "meant to prompt conversation", not written down to check off
- Draw the map together (PM + design + engineering), exposing disagreements and reaching consensus during the drawing process
- After the map is drawn, the value left behind is "the consistent picture in everyone's head"; the document is just a memo
- Output: a collaborative session of building the map together + a map serving as an anchor for conversation
Decision Rules (with source annotations)
- If your requirements are a vertical flat list, then rearrange it into a two-dimensional map of "horizontal process + vertical detail". (Chapter 5)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- Flat backlog—a long vertical list that does not reveal the whole picture or allow release slicing. (Chapter 5)
- 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)
- 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)
- Only the PM builds the map/writes stories—losing the greatest value of stories (shared understanding). (Chapter 1)
- 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:
- Match the scenario → choose a framework (build the backbone / slice releases / align understanding)
- 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]
- Execute according to the framework steps: help the user arrange scattered requirements into a backbone + tasks, and cross-cut the first version
- 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")
- 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.