A2.06 · The value ladder · dive 1
Compose the ladder
A pile of stories becomes a ladder when it is put in order. The first property: every rung is a usable capability, never a task.
The earlier modules made good stories one at a time. Composing the ladder selects, from the candidate stories, the ones that are capabilities, and stacks them so each adds value on its own. A technical chore or an outsize wish is not one rung of value. Test a candidate on the right: a capability is admitted; a task or an oversize story is rejected.
Rung or task · test a candidate
A pile is not a ladder
A pile is a set of stories with no order. A ladder is the same stories arranged so they stack: each rung adds one usable capability and rests on the rungs below it. Composing the ladder is the move from the first to the second — and it begins with a filter, because not every candidate is a rung.
A rung is a capability: a vertical slice a role can exercise and demonstrate (the A2.01 test). Two kinds of candidate fail that test. A task — “add the courses DB table” — delivers nothing a role can do; it belongs inside a rung, not as one. An outsize story — “manage the whole catalogue” — is many capabilities at once, so it is not one rung of value; it is split (A2.05) before any of its slices join. Composing keeps the capabilities and removes or splits the rest.
- pile
- A set of stories with no order — nothing says which is built first or what rests on what.
- ladder
- The same stories stacked so each rung adds one usable capability and rests on the rungs below it.
- rung
- A capability: a vertical slice a role can exercise on its own. The only kind of candidate a ladder admits.
- not a rung
- A task (no user-visible value — folds into a rung) or an outsize story (many capabilities — split first).
This dive isolates the first property — every rung is a capability. The order between the rungs is the next dive (A2.06.2), and runnability the one after (A2.06.3).
Compose four rungs into a stack
With the capabilities selected, composing is stacking them. The figure assembles four Portal stories into a four-rung ladder, bottom to top. Each slot reports that its rung is a capability, and the readout confirms the whole stack is a ladder — all four rungs usable on their own.
Drop a non-story into a slot to watch the stack stop being a ladder. Replace a rung with “add the courses DB table” or “manage the whole catalogue” and that slot turns burgundy: the readout names the rung that is not a capability, and the stack is no longer a ladder until the slot holds a capability again. Composing the whole differs from judging one candidate — the stack is a ladder only when every slot is.
A four-rung stack · set what fills the top slot
Composing a ladder is keeping the capabilities and dropping or splitting the rest — the stack is a ladder only when every rung is one.
Composing the Portal ladder
On the Portal — the learning platform this course builds — the candidate list holds six items. Four are capabilities; two are not. The composition is a filter, then a sort.
# The pile of candidates for the Portal vision. candidates = [:browse, :enrol, :open_lesson, :track_progress, :manage_catalogue, :courses_table] # Keep only the capabilities — a vertical slice a role can exercise. rungs = Enum.filter(candidates, &capability?/1) # => [:browse, :enrol, :open_lesson, :track_progress] (4 rungs) # The two that did not make it are not discarded work: # :courses_table — a task; folds INTO :browse (browse needs a place to read courses from) # :manage_catalogue — an outsize wish; split into rungs (A2.05) before any slice joins
What is left is a stack of four rungs, each a capability a learner can exercise. “Add the courses DB table” is real work, but it is not a rung: it folds into rung 1. “Manage the whole catalogue” is real value, but it is many rungs: it is split first. The ladder admits only capabilities.
The principle
A ladder rung is a usable capability, never a task. Composing a ladder keeps the capabilities and drops or splits the rest, so the stack adds value at every rung.
On the Portal
browse, enrol, open a lesson, track progress — four capabilities. :courses_table
folds into a rung; :manage_catalogue is split before it joins.
A pile becomes a ladder when only the capabilities are kept and stacked — the rest is folded into a rung or split into rungs first.
Recap — capabilities, stacked
A ladder is a pile of stories put in order, and the first thing that makes the order a ladder is that every rung is a capability — a vertical slice a role can exercise, not a technical task and not an outsize wish. Composing is a filter and a sort: keep the capabilities, fold the tasks into rungs, split the outsize stories, and stack what remains. With the rungs chosen, the next dive fixes the order between them: each rung may depend only on the rungs below it.
Next in A2.06: A2.06.2 · Dependency order — each rung depends only on the rungs below it, the ladder as a topological order, and how ordering by value reconciles with ordering by dependency.
References
Primary sources for stories as units of value composed into a plan, and where this connects in the course.
Sources
- Cohn, M. — User Stories Applied — a story as a small unit of value, not a technical task.
- Hunt & Thomas — The Pragmatic Programmer — building in small, deliberate steps that each stand on their own.
- Humble & Farley — Continuous Delivery — delivering capability in thin vertical slices.
Related in this course
- A2.06 · The value ladder — the module hub.
- A2.06.2 · Dependency order — the next dive.
- A2.01 · Value, not tasks — why a rung is a capability.
- A2.03 · INVEST — Small, the test an outsize story fails.
- Companion · Functional Programming in Elixir — the Portal's internals.