liveBook · Manning

Vertical slice

As explained in Claude at Work

A vertical slice is an end-to-end implementation that crosses the application's layers or components to deliver a complete feature path.

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 #general, Grace sees it

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

How Claude at Work covers it

How deep it goes
Develops a delivery sequence and per-slice protocol, including scenario approval, failing tests, implementation, and exit criteria.
Examples
Uses channel creation, message history, and real-time delivery as successive messaging slices with demonstrable outcomes.
What it assumes
Uses an existing strategy plan and design documents to prepare each slice’s implementation plan.
What you can do after
Evaluate and plan reviewable feature slices, with behavior scenarios and explicit approval before implementation.
How it connects
Connects vertical slices to behavior-driven development, Gherkin scenarios, end-to-end testing, and implementation planning.

Also explained in

Compare how 2 books explain vertical slice →

Related concepts

This explainer was generated by Manning's knowledge graph from the text of Claude at Work. The section links point to the parts of the book it draws on.