A rule that has to find its targets by hand does not scale. A rule that targets a shape — a file name, a folder, a signature — scales to the whole fleet. So the deepest investment is not the rule. It is the structure the rule rides on.
One shape governed every layer: one source, many projections, drift gates. Here is the whole wall of gates in one place, an honest map of what is not done, and the answer to the question the series kept asking.
A model will happily hand you a status that does not exist. So you treat its output the way you treat any untrusted boundary — declare the shape, validate against it, retry on failure — and the enum manifests you already have become the exact set it is forced to choose from.
A green test is only worth something if it still resembles production. Fixtures shared across every surface, real databases for the data layer, and injected time keep the test world from quietly drifting away from the real one.
The deepest coupling to keep from drifting is between the two halves of the product. The answer is a shared governance model: the same triple — structure, enforcement, one doc — mirrored across frontend and backend, honest about where the mirror doesn’t hold.
If you hand-maintain a Claude agent file and a Cursor rule for the same role, they drift. So the role is declared once and projected onto every framework, the tier is provider-agnostic, and a drift gate fails CI when any rendered copy falls out of sync.
A capability your app calls, your agents call, and you call from the terminal is one capability with three faces. Define it once; project it onto every transport; let a contract test refuse any face that drifts from the others.
A dashboard table is a copy of the truth, and copies drift. Unless the copy is disposable — rebuilt on demand from an append-only log of facts. Then the projection can never win an argument with reality, and new views are free.
One overloaded type smeared across storage, API, and UI is the most expensive coupling there is — every layer drifts into every other. Separate models at boundaries cost a little duplication and buy back the freedom to change one layer without breaking the rest.
A service’s edges drift as quietly as its data — an env var read three ways, a metric name typed twice. Config and metrics are tagged vocabularies too, and declaring them once removes a whole class of 2am surprises.
An error is the clearest place to see FE↔BE stitching, because a failure has to mean the same thing on both ends. We follow one real error manifest from declaration to handler to wire, and show where the generated coupling goes next.
An enum is the simplest tagged vocabulary, so it is the clearest place to watch one source become many projections. We follow a real VideoStatus manifest from YAML to Go, and look at what keeps it from drifting as it grows.
A manifest is only a source of truth if something keeps every generated copy honest. buildmere is that something — a kernel that knows nothing about kinds, a set of plugins that do, and a check command that fails the build on the first byte of drift.
Before any code generator, there is one idea: a closed named set, declared once, with a stable name and a separate wire form. Get that atom right and enums, errors, config, and metrics all turn out to be the same thing.
When generation is cheap, the bottleneck stops being how fast you write code and becomes how reliably it all still agrees with itself. This series asks one question of every layer in our stack — are we drifting? — and shows the shape of the answer.
The next engineering platform is a vocabulary engine — define codebase concepts once, generate their representations everywhere, and govern usage through policy, linting, tests, and agent behavior.