User Story Splitting (8 Patterns)
Break epics and oversized stories into independently deliverable slices using the Lawrence & Green 8-pattern framework — workflow, business rules, data, AC complexity, major effort, dependencies, DevOps, TADs.
Your team committed to a 21-point story called "manage team members" — and three weeks later it's still "in progress" because you bundled invite, remove, and role-update into one ticket. Stories with 5+ When/Then pairs aren't stories; they're epics in disguise. The 8-pattern framework gives you a deterministic way to split — each piece independently testable, deliverable, and small enough to actually finish.
Who it's for: PMs grooming backlogs, scrum masters facilitating refinement, engineering leads breaking down epics, BAs sizing work for sprints
Example
"Split: manage team members (invite, remove, update roles)" → Pattern 4 (AC complexity) → 3 stories: "invite via email," "remove member," "update role" — each with single Given/When/Then, each independently shippable in a sprint
CLAUDE.md Template
New here? 3-minute setup guide → | Already set up? Copy the template below.
npx ccplaybooks add user-story-splitting# User Story Splitting
Break large stories or epics into smaller, independently deliverable stories using 8 proven splitting patterns (Lawrence & Green, Humanizing Work). Reduce risk, enable faster feedback, maintain agile flow.
Not arbitrary slicing — strategic decomposition that preserves user value while reducing complexity.
## The 8 Splitting Patterns (in order)
1. **Workflow steps** — sequential journey steps
2. **Business rule variations** — different rules (permissions, calculations)
3. **Data variations** — different data types or inputs
4. **Acceptance criteria complexity** — multiple When/Then pairsGet new playbooks like this one
One email a week with new Claude Code workflows. Free, like everything here.
No spam. Unsubscribe anytime.
What This Does
Walks through 8 splitting patterns in order (workflow → business rules → data → AC complexity → major effort → external deps → DevOps → TADs), stops at the first match, and rewrites each split as a complete Mike Cohn + Gherkin story. Validates against INVEST criteria.
Pairs with user-story, epic-hypothesis, and jobs-to-be-done.
Quick Start
mkdir -p ~/Documents/StorySplitting
mv ~/Downloads/CLAUDE.md ~/Documents/StorySplitting/
cd ~/Documents/StorySplitting
claude
Paste the oversized story (with current acceptance criteria). Claude identifies the splitting pattern, generates split stories, and validates each.
The 8 Patterns
| # | Pattern | Trigger |
|---|---|---|
| 1 | Workflow steps | Sequential user journey |
| 2 | Business rule variations | Different rules per scenario |
| 3 | Data variations | Different data types/inputs |
| 4 | AC complexity | Multiple When/Then pairs (most common) |
| 5 | Major effort | Technical milestones |
| 6 | External dependencies | Multiple APIs / third parties |
| 7 | DevOps steps | Deployment / infrastructure phases |
| 8 | Tiny Acts of Discovery | Experiments to unpack unknowns |
Tips & Best Practices
- Walk patterns in order. Stop at the first match — don't shop for the "best" pattern.
- Pattern 4 catches most cases. If you see 3+ When/Then pairs, split along them.
- Each split must deliver user value. No "front-end story" + "back-end story."
- Validate INVEST. Independent, Negotiable, Valuable, Estimable, Small, Testable.
- TADs are experiments, not stories. Use them when no pattern applies.
Common Pitfalls
- Horizontal slicing (UI / API / DB as separate stories)
- Over-splitting tiny stories (adds overhead)
- Meaningless "first half / second half" splits
- Creating hard dependencies between splits
- Same "so that" on every split (task decomposition in disguise)