how we build — opening
Opening
Volume III ended at the moment a developer pulled a story into In progress. Everything that volume produced — the named Epic, the wireframe states, the API contracts, the schema, the ADRs, the Gherkin scenarios with their names — is now what this volume's machinery operates on.
This volume is what happens between that pull and the moment a real user encounters the feature. The machinery is familiar to anyone who has shipped software: branches, commits, pipelines, tests, feature flags, deploys, runbooks, release gates, briefings to clients and customer support. The question this volume asks is the same question every previous volume asked at its own resolution: does the meaning the brief carried still travel?
It can fail to travel here just as silently as it can fail to travel during shaping. A test that passes against an assertion no one wrote down. A commit message that says "misc fixes" when it changes an architectural promise. A feature flag enabled before a runbook was rehearsed. A release brief that says "we shipped the grading feature" instead of "Gal can now see all student scores immediately when an exam closes." Each of these is a substitution at a different gate.
The volume in one sentence. Each phase of execution carries the brief's meaning at a higher resolution into running software. The discipline is the same as upstream: produce only the resolution the next phase needs, and check at every gate that the meaning is still travelling.
The shape of this volume
Eight parts. Each one increases the resolution of working software by one step. Each one has a gate.
- The Pull — the Product Owner's walkthrough, what the developer reads, when to ask vs when to decide.
- Domain Language and Composition — domain language as a chain attribute. Ubiquitous language, bounded contexts, component composition, developer experience.
- Design Execution — the designer's parallel work. Full-fidelity screens, interaction specs, content design, handoff annotations, design system updates, UX review.
- The Pipeline — environments, trunk, conventional commits, pipeline stages including security and integrity, migration discipline.
- Testing as Chain Verification — unit, contract, visual, QA craft, accessibility, product analytics, SLOs.
- The Review — the PR as chain verification. What each role checks. Code review as architecture review.
- Feature Flags — when and when not. The lifecycle from creation to cleanup. Gradual rollout. The cost of flags.
- The Release — runbooks, the release gate, rollback discipline, the release moment, client and CS communication.
In the operational framework, this volume describes the Execution phase — the work between the ready story (Scope, Volume III) and the live feature. The Prediction continues to travel: it was named in Volume II as a baseline, kept alive through Scope in Volume III, and becomes a measurable promise here. Volume V picks up when the feature is live — checking the prediction, learning from bugs, updating the model.
A note on what this volume is not. It does not teach git, DDD, continuous delivery, BDD, observability, incident response, or security engineering. Each of those is a craft with its own deep literature. This volume names them where they appear in the chain, gives the orientation needed to see why the chain treats them the way it does, and trusts the reader to bring or build the depth elsewhere.