Control of a codebase is lost two ways when models write most of it: unrequested renames and unnamed registries. The written rules that stop both.
By Bogdan Vladoiu, 2026-11-02
ComputeShack's codebase has been written mostly by language models for over a year, under one maintainer. It builds the services the apps run on, the apps, a game and the tools that make them. This is what it took to stay in control of it, and the two mistakes that nearly took that control away.
Neither mistake is about the models being wrong. Both are about the models being helpful.
The first way control is lost: renames
A model reading a function called settle will, with some probability, decide the name is unclear and rename it applyServerIds. Nothing breaks. The tests pass. The diff is correct. And the maintainer has lost a word.
Names are how a maintainer finds things. A name chosen a year ago, awkward or not, is wired into memory, into search, into the way the author talks about the code. A better name does not restore that; it replaces a known word with an unknown one. Multiply it by every helpful rename in every session and the maintainer is reading a stranger's codebase that happens to do what theirs did.
The rule that stopped it is blunt. No rename without a blocker: a real compile error or a collision that causes ambiguity. Not a preference, not "this reads better". When a rename genuinely is required, the model stops and states the blocker, so the maintainer picks the new name. A refactor the maintainer hands over is final input, never a draft to improve.
Unrequested renames were the single biggest reason control of the project slipped. The rule is the first one in the file every session reads.
The second way: registries
The second mistake is harder to see, because it never looks like a mistake.
A model needs to hold a few instances of something. It writes a map. Or a list. Or a lazy lookup, or a small cache. Each one is a sentence of code, locally correct, and each one is a new place where instances of that thing live. Three sessions later there are four of them, they disagree about what exists, and the component's own owner, the companion object that was supposed to hold its instances, knows about none of them.
Models do this at a high rate, and the result is rarely called a registry. It is a pool, a cache, a lookup. The effect is the same: the codebase splits, and control goes with it.
The rule here is a placement rule with three cases.
- The component's companion already has a usable collection or pool. Use it.
- It does not, and the need is a plain list, map or field. Add it to the companion. That is placement, not a new concept, and it needs no permission.
- It does not, the companion is saturated, and satisfying the need would mean a new named type. Stop, state the gap and two or three options, and change nothing while asking.
Only the third case stops. Freezing on the second is itself a failure. "Temporary" is not an exemption.
Downstream code offers perspectives only: a higher order keying function, a cache of its own results, its own private context. It never allocates or collects on a component's behalf. Requiring a downstream to take over any aspect of a component is the literal definition of technical debt.
Why written rules, and why these
Both rules share a shape. Each names a behaviour that is locally reasonable and globally destructive, draws the line in a way a reviewer can check in a glance, and tells the model exactly what to do at the line: stop and ask.
That shape matters more than the content. A model follows "no rename without a compile error" reliably. It does not follow "use good judgement about renames", because its judgement is precisely the thing that produced the rename.
The rules live in one file at the repository root, loaded into every session, and that file outranks every other document in the repository. Where another document contradicts it or has decayed, the file wins and the model is told to surface the conflict rather than act on the other document. Rulings are written once, in one place; restating a ruling across files is itself forbidden, because two copies drift.
Other rules that earned their place
A few more, each written after something went wrong.
- Comments are off until further notice. Models narrate: what was done, why the edit is correct, what moved. None of it survives the next edit, and all of it buries the few comments that matter. When a comment is allowed, it is a silent-failure constraint, a spec anchor, or a temporary marker with the condition for removing it.
- Nothing is added that raises churn without an obvious benefit. No speculative helpers, no scaffolding, no defensive layers, no tests nobody asked for. Before adding anything, ask what breaks without it. If nothing, do not add it.
- A seam's default has a polarity. A default that opens content falls back to what the code holds and logs once. A default that decides access refuses and logs. Same shape, opposite default, never copied from one onto the other.
- Nothing is committed by the model. It edits, reports what changed and leaves the tree dirty. The maintainer inspects and commits, and squashes most of it.
What this is not
It is not an argument that models should write less. The house would not exist at its size with one person typing. It is an argument that the person has to stay the one who knows the code, and that this is a property of the rules, not of the model.
A human contributor would be told the same things, with the same reasons. The difference is that a human remembers being told. A model has to be told every session, in writing, in a place it cannot miss.