How a set of planning documents became a working, dockerized, versioned product: we shipped thin, end-to-end slices — each traced to a requirement, each proven three ways, each “clicked in” to version control before the next one began. Forward-only, like a ratchet.
Every feature traced to a numbered requirement. Nothing built “because it’d be cool.”
Atomic gains, locked in and never backtracked. If it isn’t committed & documented, it didn’t happen.
Each slice ran full-stack and shipped on its own — never “all the models, then all the screens.”
Consent, audit, access control and retention were the spine; features attached to them.
The person chose direction at every fork; the loop executed and verified the rest.
One numbered sequence, repeated. This is the part that made progress predictable.
Pin the slice to one spec section.
Model it, migrate, regenerate the client.
Role rules, labels, the data reads.
Every mutation: auth · role check · audit.
A client-record section or a new route.
Add the work to the daily exception view.
Fictional demo data only — never real PII.
typecheck → lint → production build.
A script drives the real UI end-to-end.
The running system now matches the commit.
Update the coverage map & handoff note → commit → fast-forward main → annotated tag. The click of the ratchet.
Static proves it compiles. Behavioral proves it works. Data proves it persisted.
The paper trail wasn’t overhead — it was how progress stayed honest and visible.
The significant, hard-to-reverse choices — the stack, the authentication model — were written down and justified before a line was built.
A colour-coded map of all 15 workflow steps, updated every slice — so the answer to “how far along?” was always current and honest.
Each ratchet click recorded what changed and exactly how it was verified — a running record any teammate or future session could pick up cold.
Active work on develop, fast-forwarded to main, then an annotated version tag. Every stable state is a named, recoverable point.
Each tag is a notch — a shippable state you can never fall behind.
Worked because
Small, reversible steps plus constant verification = low risk, always shippable, progress always visible — and the human stayed in control at every fork without babysitting execution.
The honest trade-off
The per-slice ceremony — migrate, verify, rebuild, tag — is heavier than “just code it.” Deliberately. In a regulated, audit-heavy domain, that overhead is the product.
The coding loop sits inside a wider system: delegated execution, persistent context, and prepared infrastructure.
Pubert configures the environment first: routing, storage, permissions, memory shape, and the written decision trail.
Once the environment is ratcheted into place, specialized coding agents step in for targeted repo work instead of broad system design.
Graph memory and logs keep the state alive between sessions, so work can resume from entities and decisions rather than from scratch.
The person remains the architect and auditor. Pubert is the system administrator and project manager layer, not the final authority.