the code remembers

i’ve been archiving everything from the good old days. every clone, every branch, every stash i ever made, scattered across a laptop that’s outlived three jobs. a dozen copies of the same monorepo, deduplicated down to one by git hash. three and a half years. nearly fifty engineers. nearly twelve thousand commits on main.

then i did something i’d been avoiding. i read it.

the claim

in trust scales i wrote that what we built moved in absolute lockstep. that it accrued no tech debt whatsoever. that it was something i’d never seen before or since.

memory is generous to the things we bled for. so i checked.

what held

a lot of it is as good as i remembered.

the types were designed to stop specific bugs, not to describe the code.

the core of the web client was compiled without the browser’s type library at all, so the architecture was the compiler’s problem, not a code review’s. a hook returned unknown on purpose, so wiring a click handler wrong was a type error. errors were a contract carried from the backend, through grpc, through graphql, to every client. trace ids survived every queue. ci failed if anyone forgot to regenerate code.

fifty-odd TODOs across the whole codebase. for fifty people over three and a half years, that is genuinely low.

and the output wasn’t a myth either. four thousand a year on github from one engineer, before any of us had an ai to help.

what drifted

then the rest.

three logging libraries. four ways of naming a module. go versions from 1.14 to 1.19. two error packages that did the same thing. a base class migration that never finished. lint configs, copied lovingly into five services, that nothing ever ran. a rate limiter that never limited anything.

not lockstep. lockstep in places.

where the line falls

here’s the part that surprised me.

the consistency held exactly where a tool held it. the compiler. the lint rules that failed the build. the ci check that diffed generated code. those parts are as clean now as the day they were merged.

it drifted exactly where it relied on people. where the standard lived in someone’s head, or in a document, or in how loudly it would be defended. those parts wandered the moment nobody was watching.

a standard enforced by a person lasts as long as that person is looking. a standard enforced by a tool lasts as long as the build runs.

i always wondered whether what we built was only possible because of how it was built. whether the conviction and the cruelty were the same thing.

the code answered that for me. the parts that survived weren’t held together by fear. they were held together by machines that didn’t care who you were, that told everyone the same thing, and that never once made anyone cry.

what i do now

everything i build now writes the rule down, then makes the build enforce it. a linter that runs. a check that fails. a convention with a test behind it. if it matters enough to argue about, it matters enough to automate.

and the people part — that’s the part the tools can’t do, and shouldn’t. that part is trust.

the good old days taught me what good looks like. the code taught me what keeps it that way.