03A walking skeleton first
When features cost hours, the danger is building many that have never worked together. Scrum's answer predates AI: a thin product that works from end to end, built first. AI makes it cheaper to build and more necessary to insist on.
Scrum asks for increments that work, and good planning orders them by risk as well as by value. For a new product, that means starting with a walking skeleton: the thinnest version of the system that works from one end to the other, built before any part of it is complete. Agile Planning makes the case for it, and Building It shows it as the first stage of a roadmap. None of that changes with AI. What changes is the cost of building, and with it the temptation to skip the discipline.
The team chooses the slice, keeps it narrow, decides on evidence, and changes its mind when the evidence says so; on this project, that was me.
Which question first?
The product rests on a promise: a hospital can configure it, safely. Configuration is authored in one tool, approved, published, and consumed by the application clinicians use. Each part could work on its own and still fail when joined to the rest, and until a real application had run on real configuration, the promise had never been tested. That was the riskiest question, so it came first.
In Domain-Driven Design terms, the promise sits on the boundary between two bounded contexts: the configuration tool, which writes the configuration, and the application, which reads it. The contract between them is the Baseline, an approved bundle that cannot be changed once drawn, and, as Drawing the Lines argues for critical products, the boundary is where the risk sits. The skeleton was chosen to test it before anything was built on either side. The vocabulary on both sides came earlier still, from a glossary written on 6 August that became the project's ubiquitous language (chapter 08).
I chose a deliberately narrow slice: patient management. A clerk looks up a patient, edits the record and saves it, or registers a new one. These simple workflows touch configuration, publication, the application, the database, access control and the audit trail, and they leave out, on purpose, what would have clouded the test: clinical processes, hand-offs between roles, and the safety checks that block a risky clinical action.
What did the skeleton prove?
On 14 September, a configurator laid out a page, approved it and published it, and a clerk used that page in the application to search for, register and edit patients, with every change kept in a hash-chained history and protected against two people editing the same record at once. Seventeen days had passed since the decision to build exactly that, before anything else. The skeleton had answered its question, and that made it the first gate inside the project: a question set in advance, the thinnest product that could answer it, and a decision at the end (chapter 10).
The skeleton has few features and complete foundations. No record is ever deleted: the database refuses it, whatever the application asks. Every change copies the previous version of the record into a history table, in the same operation, chained to the version before it by a cryptographic hash, so that a change to the history shows up when the chain is recomputed; a routine check that recomputes it, and a copy of the chain kept outside the database, are still to be done (Appendix C). That machinery has to be identical on every table, which is the kind of work people do inconsistently by hand. It was specified once, in the architecture, and Claude applied it to every table in exactly the same way.
The order mattered. Just enough of the configuration tool was built to feed a real application, then a thin slice of the application to consume it, then the tool was revisited with what the slice had taught. The standard was no stubs, and nothing half-built that would come back to bite later; what was left out on purpose is recorded as a known gap, with the reason it was deferred. Keeping the skeleton narrow meant saying no: at the end of September I deferred a sound proposal to add clinical safety controls, because the foundations were not finished.
Architecture by experiment
Scrum in Name Only calls for architecture that is risk-driven and continuous: just enough, and just ahead of need. Testing an option used to mean building it, and building was the expensive part, so most decisions were made on paper. When a prototype costs hours, the options can be built and tested against the real requirement before anyone decides.
The configuration tool's first version used JSF, the user-interface framework that comes with the Java application server, and it soon produced a real bug. The hardest interaction in the tool, dragging a field from a palette onto a page layout, was built twice: with Apache Wicket, and with Thymeleaf and htmx. Wicket gave each user a private copy of the page, so two technicians working on the same layout would not have seen each other's changes. A deliberately provoked race showed that two edits arriving at the same moment could silently lose one of them, whatever the framework; that became a recorded risk and a rule. The choice fell on Thymeleaf and htmx, on the evidence of the experiment.
Inspect and adapt
Scrum's inspect and adapt only means something if the evidence is allowed to change the plan. It did, several times, and each change is on record. Most came from using what had just been built; four were large enough to need a formal BMAD change proposal. When a story costs hours, reverting one is the normal price of learning.
Four times the evidence changed the plan
- From blocks to fields. Groups of fields, such as an address, were placed on a page as one unit, as agreed. Seeing it work, I realised people needed to place individual fields, and I reversed a decision taken three weeks earlier.
- A page that missed the point. The page for managing captions and translations worked as specified, and was wrong: it was a spreadsheet where people needed context. It was redesigned.
- Built and removed the same day. A capability added to support search had no use once the search page was simplified. Two stories of real code and a database migration were removed in the same session; nothing was kept "in case".
- Restrictions as configuration. Which roles may perform which actions on a page started as a setting in the access-control module. Live testing showed it belonged with the page's own configuration, approved and published with it. It moved.
The adapting is not finished. The way a new configuration is published turns out to be cumbersome, and it does less for safety than it should. That is the subject of chapter 09.
For your own project
- Build the walking skeleton first, and insist on it more when AI writes the code: the cheaper the features, the more of them can rest on an assumption nobody has tested.
- Keep the choice of slice with the team: the one that answers the riskiest question, kept narrow even when good proposals arrive to widen it.
- Have disputed architecture options built and tested against the hardest real case, and let the evidence change the plan.