In tech, it is easy to mistake a trend for a fundamental shift. This is not a trend. The models writing code and discussing architecture today aren't just moving one more task; they are moving the programmer's professional identity.
An old example makes it clear. When calculations were done with slide rules, engineers spent mental energy on the operation itself. Then the calculator arrived and that friction vanished: attention shifted to making better decisions, not calculating. The job didn't die, it shifted toward judgment. The tool took over the mechanical part and freed up the part that actually adds value. Programming is undergoing the same shift. If we still measure value by "lines written per person," we are already late.
The useful question isn't whether a model generates a correct function in 8 seconds. It already does that. The useful question is who designs the system so that result doesn't break production, doesn't leak data, doesn't trigger absurd costs, and doesn't turn the backlog into a technical debt factory.
Less typing, more systems engineering.
Some people are waiting for the AI bubble to burst to "go back to normal." It is not going to happen. Valuations might drop, startups might close, media noise might fade. The technology is staying. It has already made its way into IDEs, support pipelines, search engines, monitoring, security, internal documentation, and operational flows. When a technology enters so many layers at once, it doesn't retreat out of nostalgia.
I also hear this: "if AI writes code, then programmers are redundant." No. What's redundant are roles that only exist to translate tickets into CRUD without business context or operational responsibility. The market will ask for a different mix:
- people who model problems and define system boundaries
- people who evaluate model output with technical and product judgment
- people who build real observability for agents and automations
- people who connect software with data, cost, risk, and daily operations
That is still IT work, but it doesn't fit the old "just a programmer" label.
And there's an uncomfortable part worth saying directly. Before, the advantage came from the mind: whoever thought better solved better, and your own brain was enough. That still counts, but it is no longer enough. More and more, the result depends on how much compute you have access to, and compute costs money. Training, running agents, serving models, iterating fast: it all costs money. To put it bluntly, we are starting to buy intelligence. Those with capital for GPUs and tokens start ahead of those who only bring talent. For a community like ours, this is a specific risk: if the compute budget weighs more than judgment, we have to fight for both, without giving up access or brains.
This hits us directly at MexicoDev. If we want a strong community in three years, we need to raise the bar now: agent flow design, response quality evaluation, security applied to prompts, cost per token control, and architecture to integrate AI without breaking what already works.
The conclusion is simple: the profession is not ending; it is rearranging. Staying still waiting for "everything to return" is the worst possible strategy. In tech, the prize almost always goes to those who adopt early with discipline, not those who arrive late with excuses.