I've been writing software professionally for fifteen years. Most of that has been inside the enterprise — the kind of place where reliability is a moat, where every architectural choice carries five years of consequence, and where the gap between "demo" and "production" is measured in audits, runbooks, and dollars.
Which is why I take the AI moment seriously.
The thesis
A lot of senior engineers I respect are skeptical of LLMs. Their skepticism is earned: they've watched ten generations of "this changes everything" wash through and recede, and they know what it costs to retrofit a fad into a system you can't restart.
I think this one is different, and here's the short version of why.
LLMs are not a feature. They're a new substrate for software — a thing you build on, not a thing you bolt in. The shape of code is changing the same way it changed when we moved from machines to networks, and from monoliths to services.
What changes
- The unit of leverage moves. A senior engineer who can wire reasoning into a system gets back hours per week of work the rest of the team used to do by hand.
- The expensive skill becomes taste. Models will draft almost anything. Knowing which draft is the right one — and which "good enough" answer is going to wake someone up at 3 AM — becomes the bottleneck.
- Reliability isn't replaced, it's relocated. All the hard-won enterprise discipline I've built up still matters. It just lives one level up from where it used to.
What I'm betting on
That the senior engineers who lean into this — not as cheerleaders, but as the people who know what production-grade actually means — become the ones who get to build the next decade of software.
I'm betting that's me. We'll see.