A vertical slice delivers a feature path across an application’s components, rather than completing one component at a time. For example, a messaging slice can connect a browser UI to the services needed to create and list channels. The result is something a user can demonstrate, not just a finished backend or frontend component. section 6.3 section 6.6
Break a larger feature into thin slices that are easy to review. Start with a strategy for the full feature, then make a delivery plan that identifies each slice and its demo. Create an implementation plan for each slice so its scope and approach can be reviewed before building begins. section 6.6 section 6.7
Table 6.1 The delivery plan derived from the strategy — focused on small easy-to-review deliverables
| # | Slice | Demo at the end |
1 |
Channels: create and list (carries the BDD harness) |
Ada creates |
2 |
Channel admin and membership |
rename, archive, add/remove members, private channels |
3 |
Messages: send and read history |
send + infinite scroll; Grace sees on reload |
4 |
Messages: edit and delete (settles D8d) |
edited marker, tombstones, admin delete |
5 |
Real-time delivery — broadcast only |
two windows, live receive |
6 |
Socket write path, optimistic send, typing |
instant render, rollback, typing indicator |
7 |
Record the decisions |
ADRs, register, design docs, READMEs |
This delivery plan progresses from channel creation to message history and real-time delivery, with a concrete demo for each feature slice. section 6.6
A slice need not contain every capability planned for a feature. For example, sending and reading message history can come before real-time broadcast. When deferring a capability, clarify whether the earlier path will be extended or replaced. section 6.6
Plan a messaging slice
Start with a goal such as: “Build a demonstrable messaging UI, using Gherkin specifications to drive the work.” Then ask for a delivery plan of small, reviewable features, each starting with scenarios and followed by a build plan. For the first slice, the demo might be one user creating a channel and another seeing it. section 6.3 section 6.6
Use the scenarios as the slice’s behavior contract. Review and approve them before implementation; a comment or silence is not approval. Run them and check that they fail for the intended missing behavior, not because the test harness is broken. Build outside-in until they pass, adding backend integration tests with the code they cover. If behavior is wrong, fix the implementation rather than changing a scenario to fit it. section 6.6
Listing 6.3 The delivery protocol every slice follows
**Gherkin first.** Write the `.feature` scenarios. Run them. Watch them fail for the right reason (missing step, missing endpoint — not a broken harness). **Build outside-in** until they pass. Backend integration tests land with the code they cover. **Never edit a scenario to fit the implementation.** Fix the implementation. **Exit criteria** for every slice: its scenarios green **Branch per slice** Per CLAUDE.md: create the branch, leave the tree dirty, **never commit** — that's the user's.
The delivery protocol makes passing scenarios the exit criterion for each slice and sets a branch-and-review workflow. section 6.6
When an AI assistant helps plan or build, review its proposed boundaries and ask for clarification on uncertain decisions. Smaller slices keep the work visible and give you a chance to steer before substantial code is produced. section 6.6 section 6.7

