Ship a complete thought

On moving day, the garage contained boxes, tools, equipment, and the residue of several unfinished systems. A complete organization plan would take time. Norma needed to park inside that night.

So the floor became the deliverable.

Enough open concrete for the car did not finish the garage. It restored one capability inside the containing system, and it left the system in a valid state while the larger initiative continued.

That is the shape of a coherent slice.

Small is not the same as sliced

"Install one cabinet" is smaller than "organize the garage." It may still deliver no usable capability. The cabinet can be assembled while the tools it was meant to serve remain inaccessible and the circulation path remains blocked.

"Make yard maintenance operable without hunting for equipment" crosses more types of work. A shelf moves. Related tools get grouped. Retrieval paths stay understandable to both people using them. The result is usable even if the reloading bench and household storage remain unfinished.

A task describes activity. A slice describes a complete change in capability.

The distinction matters in software because horizontal plans sound orderly: database this week, service layer next week, interface the week after. Each week may complete a technical layer while no user or operator can do anything new. Smaller work has been produced. Value has not.

A coherent slice is the smallest complete thought you can safely integrate.

Write the slice before the task list

Use this artifact before decomposing implementation:

Now test it against the garage:

The last row appeared after this chapter's first draft. It did not replace the earlier preparation slice; it extended it with a narrower, measured capability. "Assemble the Dillon" would have described activity. "Produce a fifty-case set accepted through sizing, headspace inspection, replacement, and swaging" describes what the garage can now do.

The qualification matters. The current set still carries sizing lubricant and preparation residue. Calling it production-ready would make a component on the bench grade the containing process. The shipped capability ends at swaging; the next slice begins with the planned final cleaning.

The outlet repair is especially instructive. Repairing one outlet sounds like a task. The coherent capability was broader: permanent freezer power without an extension cord crossing the route Norma and Sean used. The proof belonged to the surrounding garage, not to the receptacle. An electrician's tester could show voltage while the cord still crossed the floor.

The software fault slice

Hold the plate's Ruby change is also a slice. Its capability is not "add HaltedRun" or "inject ProductionLine." Those are implementation tasks.

The capability is:

When production encounters its first station fault, stop automated movement, preserve every decision and in-flight fact already established, derive a recovery assessment, and return control without releasing incomplete work.

That statement crosses the classifier, readiness gate, press, recovery assessment, result protocol, and outer acceptance test. The final inspection is part of the slice through refusal: the test proves it is not asked to release halted work.

The residue is explicit:

• no automatic execution of the recovery plan;
• no operator authorization protocol;
• no physical recovery proof;
• no settled provenance owner for an interrupted attempt.

The residue does not make the slice incomplete. It bounds the capability. The system can now halt honestly and return enough state for a later recovery decision. It cannot yet claim to resume production.

Prove the body walks, then remove the crutches

A walking skeleton may begin with hard-coded values. Its job is to prove that the architectural path exists: request enters, orchestration runs, adapters are selected at a visible seam, and a response leaves.

That proof scaffolding is temporary by design. A hard-coded success that proves routing should not quietly become the domain rule. A fake registry used to exercise wiring should not become production state because it is already convenient. Once the path is proven, replace each hard-coded claim under the pressure of the next failing behavior test.

The sequence matters:

1. Make the smallest path walk.
2. Keep the outer test red on real behavior.
3. Drive each inner joint with a focused test.
4. Return to the outer test.
5. Remove or rename scaffolding that no longer describes its temporary job.

Gall's law applies at slice scale. A complex working system grows from a simple working system. "Simple" means a complete small organism, not a pile of finished organs waiting for assembly.

Slices have due dates

Not every capability is due at the same time.

Parking was immediate and continuous. Safe circulation became urgent when the garage returned to daily use. The cabinet door needed to open before its placement was committed. The progressive press does not need to support live recovery until it is used, but the recovery body plan needs to exist before a fault can turn ambiguous.

Adding a due condition to residue prevents "explicitly unfinished" from becoming "forgotten forever":

The final press mounting used to be residue here. It closed at its due condition: after the neighboring layout and operating envelopes were verified, before the first physical cycle. A completed obligation belongs in the record, not forever in the backlog.

The full obligation detail stays current on The Lab Ledger.

A narrow slice can create debt if the surrounding initiative never returns. The remedy is not to wait for everything. It is to make the boundary and due condition visible.

Define one complete thought

Take a feature currently described as a noun or activity: "notifications," "new database," "admin page," "refactor checkout."

Fill the card:

Then read the capability aloud without implementation nouns. If it cannot be understood without class names, tables, endpoints, or screens, it may still be a task list. If it delivers value only when three future slices arrive, it may be a horizontal layer.

What a slice does not excuse

Coherence is not permission to bundle every nearby improvement. A slice crosses the layers required for one capability. It does not absorb unrelated refactoring because those files are open.

Nor does a green test inside one subsystem prove containing-system success. The outlet is not done because it has voltage if the cord still creates a hazard. The fault protocol is not done because PressRecovery returns an assessment if the application keeps cycling.

Ship when the named capability is true, the system remains valid, and the residue is honest. Then the next question begins: after success, what keeps the capability available for the second run?