Folks, we won’t always need software engineers. I say that as one. And I say it with a deep respect, because this isn’t just about technology. It’s about identity. It’s about a craft many of us have spent our lives inside.
The Golden Age of Software Engineering is in its final act. Not ending abruptly, not collapsing, but closing with momentum still visible and direction already set. And if we are honest, it feels less like decline and more like standing at the edge of a Renaissance, a transition from one way of building the world to another. There is something remarkable about being here for it.
If you step back and look at the arc, it has been there all along. We began close to the machine, writing in bits, then in languages, then in frameworks, then in systems. Each step pulling us further away from mechanics and closer to what we actually meant. From bits to code to systems to intent. That is the whole story.
Software was never the destination. It was the bridge. A necessary one, a powerful one, but still a bridge between what we think and what becomes real. We got very good at building it. We argued over it, perfected it, built careers and identities around it. But bridges are not where you stay. We built a career around translation, and now translation is being automated. The shape of the work is already changing.
The distance between thought and thing, neural latency, is shrinking. It used to take days, weeks, sometimes months to turn an idea into a working system. That effort defined us. The last few years have brought us significantly closer. Systems can already write, reason, assemble, and refine. Not perfectly, not completely, but enough to change the trajectory. And when that distance collapses, the role built to bridge it changes with it.
This is the part most people are avoiding. The role of the software engineer, as a translator of thought into code, is not permanent. It is a phase between intention and execution.
We do not lose because we picked the wrong library. We do not fail because our syntax was not elegant enough. We fail because we did not understand what needed to exist. And now, with systems that can build whatever we describe, that mistake does not slow us down. It scales. The constraint has moved upstream, into clarity of intent, definition of outcomes, quality of constraints, and judgment. The hard part is no longer writing the system. It is knowing what system is worth writing.
We are not the last generation of engineers. We are the last generation who must translate thought into code. And that carries a responsibility. To capture what we know before it disappears into abstraction. To make explicit the judgment we have been carrying implicitly. To codify the principles behind the craft in a way that future systems can learn from. Because what comes next will not learn from syntax. It will learn from us.
There is a privilege in being part of this moment. Perhaps a once-in-a-generation shift, perhaps rarer than that. An opportunity that comes once in the whole of human history, to stand at the end of one era and help shape the beginning of another.
We solved mechanics. Now we are responsible for meaning, and for what comes next.
If you are thinking about where this leads, I explore this arc in A Brief History of Engineering.
You can keep optimizing the translation layer, or you can start working on what comes after it. One of those is the future. The other is already the past.
Like this article? Join the update list.