liveBook · Manning

Delivery plan

As explained in Claude at Work

A delivery plan is a staged plan that organizes work into manageable increments for producing and reviewing a deliverable.

A delivery plan breaks a large piece of work into manageable, reviewable stages. It sits between the overall strategy and the implementation plan for each task. The aim is to get feedback before a large amount of work has been built in the wrong direction. section 6.0 section 6.1

Use the strategy as input and consider dependencies when ordering the stages. Each stage should be small enough to review and demonstrate. The resulting delivery plan then feeds the more detailed implementation plans. section 6.5 section 6.7

Plan messaging in slices

For a messaging feature set, a delivery plan can start with channel creation and listing, then move through membership, message history, editing, and real-time delivery. Each slice has a demonstrable result; the first also carries the BDD test harness. Real-time broadcast is scheduled after the initial HTTP-based message work. section 6.6

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

Compare the seven slices with the demonstration planned for each one. section 6.6

To generate a plan with Claude Code, clear the session context, enter plan mode, and point Claude at the strategy and relevant design documents. Ask for chunks that are easy to review, with Gherkin tests followed by an implementation plan. The session may retain an out-of-date CLAUDE.md, so check what context the agent is using. section 6.6

Adapt the request

“Check the strategy plan and break the feature set into chunks that are easy to review. For each chunk, start with Gherkin tests, then prepare a build plan. Write the delivery plan.” section 6.6

Discuss the proposed grouping rather than accepting it automatically. For the messaging work, Claude offered thin vertical slices, larger slices, or a frontend/backend split. Thin slices were chosen to make confidence possible with minimal review effort. Ask for clarification when a proposed step might be either a foundation for later work or throwaway work. section 6.6

Skim the strategy and delivery plans, then review each implementation plan. Put the deepest review into the BDD scenarios: stop after the feature files are written, revise them until they describe the intended behavior, and give an explicit go-ahead before building. For the messaging slices, scenarios must fail for the right reason before implementation and pass as the slice’s exit criterion; fix the implementation rather than editing scenarios to fit it. section 6.5 section 6.6

Listing 6.4 The guard clause Claude added, telling future agents to stop and wait for approval
**Stop and wait for approval.** Present the finished `.feature` files
and **do not start building.** The scenarios are the contract for the
slice, and they are the cheapest thing in it to change — so expect
several rounds of "that's not the behaviour I want", "add the case
where…", "drop that one". Rewrite and present again. Only an explicit
go-ahead moves the slice to step 3; silence, a question, or a comment
on one scenario is not a go-ahead for the rest.

Use the stop-and-approval clause as a concrete checkpoint before implementation begins. section 6.6

How Claude at Work covers it

How deep it goes
Works through generating, sequencing, and reviewing slices, including approval and exit criteria for each slice.
Examples
Uses a messaging application with seven slices, from channel creation through real-time delivery and recording decisions.
What it assumes
Assumes an existing strategy plan and relevant design documents as inputs to delivery planning.
What you can do after
Apply it via Claude Code to generate and review a staged delivery plan from a strategy.
How it connects
Connects strategy, implementation planning, dependency planning, behavior-driven development, and Gherkin scenarios.

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.