For a long time, people thought they protected their systems by protecting their code. That was not foolish. It was a sensible answer to a sensible scarcity. Code was expensive. You wrote it slowly, changed it carefully, and once you had it, you tried to keep it in the same place for as long as possible. From that economy came the virtues: reuse, abstraction, central instances, careful ownership. Almost every rule of the old software craft was an echo of the same quiet fact: **writing was expensive. Coordination was more expensive.**
Then the price fell.
It did not happen in a single crack. It happened the way real era changes usually do: first as a suspicion, then as a habit. A surface that would once have taken a week stood up in an afternoon. A rename that used to cost half a sprint was tried three times before coffee. Entire layers that no one would have separated before, for fear of the follow-on cost, were pulled apart, moved, rebuilt. Not because people suddenly became braver. Because writing itself had lost its price.
And with it, the place where one could build well or badly began to move.
When code became cheap, an old illusion died: the illusion that the true engineering lived *inside* the code. No. Not anymore. If the inside can be generated, discarded, and replaced at speed, then permanence lives somewhere else: at the boundaries. In the data model. In tenant isolation. In permissions that cannot be talked around. In deployments that can move backward. In the question of what is true, and who has to prove it. **You no longer centralize the code. You centralize the contract.**
That was the liberating half.
The other half was more dangerous. Cheap code is not only faster to build. It is also faster to build wrongly. What once took days now takes minutes, and that means mistakes take minutes too. A flawed line in an ingestion path, an unguarded edge case in a routing script, a silent overwrite at the wrong moment: suddenly the danger was no longer slowness, but silence. Systems could break broadly without becoming loud. They could look healthy and already be drifting. The new catastrophe was not the spectacular crash. It was the friendly, plausible continuation on corrupted ground.
That was when they understood that discipline would have to migrate with the work.
If code is cheap, rigor does not become unnecessary. It relocates. Away from rituals that existed to manage scarcity, toward guards that can restrain speed. Observability instead of mere inspection. Reversibility instead of reverence for what already exists. Hard edges instead of internal cleverness. And truthfulness as a feature, because once a machine sounds good enough, it can quietly teach people to forget the difference between *plausible* and *grounded*.
They did not have the right language for it immediately either. But they began to feel that something old had ended. The profession was not disappearing. It was moving house. From writing to judgment. From construction to composition. From the question *“How do we build this?”* to the harder question *“What is this allowed to stand on?”*
That was the day code became cheap. Not the day software became easy. More nearly the day honesty, boundaries, and taste became more expensive than typing.
*— H.V.*