Copies Don't Inherit

Last month I installed the same image pipeline into three of my sites — a furniture shop, the company site, an archive: the same scripts, carried over by hand, three times. There is no shared library underneath them. The copies have already begun to diverge, and I am letting them. Twenty years of engineering doctrine calls this the cardinal sin — repeat nothing, factor everything — and I spent years obeying it. What running a small fleet of systems has taught me is that the doctrine prices one debt and ignores the other. Duplication is debt you can see. A shared abstraction is debt you cannot: coupling, billed at change time, at an interest rate nobody quotes you. And underneath the whole trade, the arithmetic has quietly moved — because the entity maintaining my copies is no longer a person who resents repetition.

The invisible bill

I ran the experiment in the doctrinaire direction first. The studio once kept a shared package for interface parts — one source of truth, every site drawing from it, exactly as the textbook draws it. Then each site's needs began pushing small divergences into the shared code, every divergence guarded by an option, until the package was a museum of compromises that no single site had chosen and every site had to walk through. Changing anything meant consulting the needs of everyone; the abstraction had made every consumer a stakeholder in each of its futures. That is the structure of the invisible bill: sharing is free at the moment of writing and charges at the moment of change, and the invoice arrives years later, itemized only as why is this hard. If you have never shipped code, you have still paid this bill: it is the company-wide template nobody is allowed to touch, because every department's exceptions live inside it. The fix, in my case, was deletion — not the first time deleting the clever layer has been the fix here.

The visible bill

Copies charge honestly, which is different from charging nothing. A fix for a flaky upload — a retry, a few lines — made it into two of the three copies and not the third, and weeks later the third failed exactly where you would predict. That is the tax, it is real, and I pay it with open eyes, because a missed copy is a grep away: findable, boring, flat. An entangled abstraction is an excavation. And sharing couples more than code. Several of my apps share a single payment account, and its webhook delivers every checkout to every app's endpoint — each app had to learn that addressed to me is a claim to verify, not a fact it may assume. Nothing was broken; an assumption I didn't know the copies were making had simply stopped being true. That is the subtler clause in the sharing contract: shared anything couples the assumptions you never wrote down.

A virtue indexed to a price

Don't-repeat-yourself is not a law of nature. It is a response to a price: human repetition is expensive, tedious, and error-prone, so we factored it out and promoted the factoring into a virtue. The repetition in my studio is now performed by an agent that does not tire of it and does not resent it, and propagating a fix across three copies costs me one sentence of instruction — the retry that went missing took longer to notice than to fix everywhere. At that price, most of what the abstraction protected me from has stopped being expensive, while everything the abstraction itself costs has stayed exactly where it was. I am not proposing a rule; a rule is how this kind of observation curdles. I am reporting a repricing: a fifty-year-old virtue turns out to have been indexed to the cost of human labor, and the index moved. The three copies in my studio are not negligence. They are the new arithmetic, written down three times.