The design drifts

The code stops being one design that a person can reason about: features that do not fit, copies that disagree, faults that are hidden.

Each failure below is a row of the grid, with what holds it at each rung.

  • Throughout In place across the stack.
  • In places In some projects, or for part of the failure. The entry says what is left out.
  • Out of reach This rung cannot hold the failure.
  • Wanted More is intended here and not built.

Design drifts to the model's average

Features that do not fit get built, and designs default to whatever the model has seen most often.

Person: One owner per project

Coverage
Throughout
Does
One person sets each project's scope, design and non-goals.
Fails
When a non-goal is not written down, and the agent fills the gap with its own defaults.
Cost
The project depends on one person, and a successor gets the code and its public docs but not the planning notes kept outside the repos.
Evidence

Written: Conventions in loaded files

Coverage
Throughout
Does
The stack's conventions live in skill and project files that sessions load, each section leading with the rules that most often go wrong.
Fails
When a rule goes stale and misleads every session that loads it, and when rules pile up unpruned.
Evidence

Tool: Lints for the mechanical rules

Coverage
In places
Does
Lints and audits enforce the conventions that have a mechanical form: import paths, unique export names where a project turns that check on, denied Rust lints and the crate graph.
Leaves out
Nothing checks the naming forms, the styling ladder or whether a feature belongs. Only their mechanical edges are checked, such as the case lints of Rust and the class diagnostics of fuz_css.
Fails
When a green lint run is read as the conventions being followed.
Evidence
Listed

Shape: Fit is a judgment

Status
Out of reach
Why
Whether a feature belongs is a judgment about the whole design, and no structure makes that call.

Two copies drift apart

Duplicated code diverges, a name is translated at a boundary, or a type says one thing while the validator checks another.

Written: One name, one copy, no shims

Coverage
Throughout
Does
The written rules give one identifier to the same thing in TypeScript, Rust and SQL, allow no compatibility layers or re-exports, and move shared code into one place: on first use when its reuse is known, and otherwise on the third copy.
Fails
When an outside consumer exists and the migration is no longer the maintainer's to finish.
Cost
The naming goes against TypeScript's usual convention, and a breaking change has to be carried through every consumer at once.
Evidence

Tool: Drift checks and twin suites

Coverage
In places
Does
Each TypeScript gate fails on a drifted generated file, and shared suites hold the wire-visible names and shapes of the TypeScript and Rust twins equal. The shared case tables of fuz_forge and fuz_schema run on both sides on every change.
Leaves out
The Rust legs of the cross-backend suites run on demand, and nothing checks internal names.
Fails
When a path is tested on one backend only, and the twins agree on the happy path and drift at the edges.
Wanted
The Rust legs of the cross-backend suites in CI.
Evidence
Listed

Shape: One schema, one library

Coverage
In places
Does
Within TypeScript one schema gives each data shape its type, defaults and validation, and each shared concern has one library.
Leaves out
The Rust twins and the wire types of tsv are written by hand beside what they mirror.
Fails
When a type is written by hand beside the schema it should come from.
Evidence

A fault is absorbed and the program runs on

A misconfiguration, a changed schema or a missing capability is absorbed at runtime, and the program keeps running wrong.

Written: Fail loud, not just closed

Coverage
Throughout
Does
The written rules have a server refuse to boot on a misconfiguration with a security consequence, rule out an optional capability that quietly falls back to a platform default, and make a test stub throw unless a test says otherwise.
Fails
When a new fallback reads as resilience and nobody asks what it hides.
Evidence
  • The spine rules, under "Fail loud, not just closed"
  • The dependency-injection traps, on an optional capability with a platform fallback
  • The same reference on testing, where a stub throws by default

Tool: Schema drift guard

Coverage
In places
Does
A test asserts each table's named column list against the live schema, in both directions, so a column added or dropped without its list fails.
Leaves out
It covers the database schema only.
Evidence
Listed

Shape: No quiet path to take

Coverage
In places
Does
Where a read names its columns, a dropped column is an error at first read, where a wildcard would hydrate it as undefined. Rate limiters built through the one mode cannot disagree about whether they enforce, and the kernel box of gro has no flag to opt out.
Leaves out
The first two hold only where code follows the rule that asks for them, and code outside all three can still catch an error and carry on.
Evidence
  • The database reference on named-column projections, where a dropped column fails loud
  • The spine rules, on building every limiter through one mode
  • The Rust rules on the kernel box, which fails closed with no opt-out
Listed