I don't remember exactly when it happened, which is probably the most interesting part.
There wasn't an announcement. Nobody upgraded a toolchain and declared victory. There was no meeting where someone said, "From now on, this will be easy."
I just noticed one day that I wasn't worried about the code anymore.
I was working on something small — the kind of internal tool you build because doing it manually for the third time feels embarrassing. In the past, this would have meant a few evenings of careful thought: setting up the project, sketching the models, worrying about edge cases that might never happen.
This time, the scaffolding appeared almost instantly. The boring parts were… already done. Tests existed before I'd decided how much I cared about them. The code was fine. Not brilliant, but fine in the way furniture from a flat-pack store is fine: solid, predictable, and not something you're emotionally invested in.
And that's when it became clear that the hard part wasn't writing the code.
The hard part was deciding what the tool should actually do.
I spent more time thinking about whether a button should exist than about how it worked. I went back and forth on defaults. I deleted features I'd just added, not because they were difficult, but because they felt unnecessary.
The interesting problems had moved upstream.
I still wrote code. Plenty of it. But the effort had shifted. The thing that required energy was judgment: knowing when something was "enough," and when it was just noise.
It felt less like engineering and more like editing.
At some point, I realised this wasn't a one-off. This was the new shape of the work. Writing code hadn't become irrelevant — it had become cheap. And when something becomes cheap, you stop optimising for it.
You start optimising for taste.