The evolving role of a developer - and what it taught me about adaptability
Is AI evolving to become part of our business a weakness for us developers with a decade of experience, or can it become our strength?
The way it used to be
When I started programming, there were no AI tools that could help you move forward when you got stuck. There was Google, there was Stackoverflow, and there were books. And if none of them had the answer, you just sat there, alone with your code, trying things until something worked. Sometimes it took hours. Other times it took days. And it wasn’t because you were bad at what you did, it was simply how you learned.
I clearly remember those evenings where I sat staring at the same function for hours, because I couldn’t figure out why it wasn’t behaving the way it should. I read forum posts from people who had similar problems three or four years earlier, hoping that their solution would also work in my case. And when it finally worked, after all that time and frustration, there was a feeling of pride that is hard to describe. Not because the solution was necessarily beautiful, but because I had fought my way to it on my own. That process shaped me as a developer. Not just technically, but mentally as well. I learned to sit with problems without giving up, and I learned that the slow path was often the one that gave the deepest understanding.
There was an honor in it. A quiet, personal honor in being able to write code from scratch and knowing exactly what every single line did and why it was there. It wasn’t something you talked about loudly, but it was something you carried with you as a developer. A kind of foundation that grew stronger with every bug you found and every solution you reached on your own.
The moment I realized things had changed
Not long ago I was scrolling past a meme online. It said something along the lines of: “Today I saw someone sitting at a café writing code manually, like some kind of psychopath.” It was meant as a joke, and most people probably just laughed and scrolled on. But for me it stopped me for a moment.
Because what was being made fun of was exactly what I had spent an entire decade learning to do well. Sitting down and writing code myself, understanding it, shaping it with my own hands. What was once the norm, what was once the craft itself, had now become something people thought was strange. Not because it no longer worked, but because the pace of the industry has changed so much that the manual work now feels slow compared to what AI can deliver.
I didn’t get angry about it. It was more of a quiet realization. A sense that the industry I grew up in no longer looks the way it did. And that it happened gradually, almost imperceptibly, until it was suddenly obvious.
How developers work today
Today, AI tools are built directly into the development environments we work in. Features that previously required research, consideration and time can now be generated with a couple of well-formulated prompts. And for many developers, that has become the primary way of working. Not as a supplement, but as the very foundation.
That is not necessarily a problem in itself. Technology evolves, and the tools we use evolve with it. But what I observe is that an entire generation of developers is now entering the industry without ever having sat with the code the way we did. They haven’t spent years learning the language from the inside. They haven’t debugged for hours only to finally understand why something failed. They have instead learned to formulate the right questions to an AI, and that is a skill in its own right, but it is not the same as understanding what is going on beneath the surface.
When you have spent years learning a programming language properly, you develop an intuition for what works and what doesn’t. You can look at a function and sense that something is wrong, even before you’ve found the bug. That intuition doesn’t come from prompts. It comes from experience, from mistakes, and from the slow process of building understanding layer by layer. And that is the part I worry we are losing.
What I know is coming
I am not naive. I know that in a few years it will be unrealistic to expect a client to pay a developer to sit for months manually writing a large web application from scratch. Not because the work has no value, but because AI will be able to accelerate the process so drastically that the manual pace simply cannot compete on price and delivery time.
And this is not just a feeling. If you look at where we were just five years ago, and compare it to what AI can do today, the direction is clear. We are not yet at a place where you can simply describe what you want and AI delivers it flawlessly. But we are closer to that point than most people think. And that development is not stopping.
It doesn’t mean the job of a developer is disappearing. But it means the job description is being rewritten. The developer who can only write code manually without understanding how AI can be used as a tool will slowly fall behind. Not because their knowledge has become irrelevant, but because the way that knowledge needs to be applied is changing fundamentally.
How I found my way through it
I have chosen not to stand still. Over the past couple of years I have slowly incorporated AI into my workday, not as a replacement for what I know, but as an extension of it. I have a decade of experience designing systems, and that experience doesn’t just disappear because new tools have arrived. On the contrary, it has proven to be even more valuable now than before.
When I start a new project, I still design the architecture myself. I still think about the structure, about how the parts should connect, and about which decisions make sense in the long run. That is where AI cannot replace me, because that part requires an understanding of the whole that only comes with experience. But once the foundational design is in place, I use AI to help me write code that is more secure, more efficient, and more sustainable than what I would be able to produce alone in the same amount of time.
I don’t vibe-code. I don’t hand over control to an AI and hope for the best. The distinction matters, because when you vibe-code, you often end up with a project where the complexity grows so large that you lose all oversight. You no longer know what is up and what is down, and when something fails, you have no idea where to start looking. That is a dangerous position to be in as a developer.
Instead, I use AI as a sparring partner…
For simple functions I ask it to help me write the best possible version with a focus on efficiency, resilience and sustainability. And because I have the technical background to evaluate what it delivers, I can quickly see whether the output is good enough or whether it needs adjusting. That is where the interplay happens. Not by replacing my knowledge, but by using it together with a tool that can supplement it.
Why old-school developers will still matter
This is the part that gives me peace of mind, and the part I hope can give other experienced developers the same. Because even though the industry is changing, and even though the way we work is becoming something entirely different, the value of deep technical understanding is not disappearing. It is actually becoming more important.
Think about it. The more code that is generated by AI, the greater the need becomes for people who can read that code critically. People who can assess whether it is secure. Whether it is efficient. Whether it actually does what it is supposed to do, and not just looks like it does. That competence doesn’t come from being good at prompting. It comes from years of experience writing, failing, fixing and understanding code at a deep level.
The newer developers who have exclusively learned to work with AI will at some point run into problems they cannot solve, because they never learned to understand what is happening beneath the surface. And when that happens, it is those of us with that experience who can help. Not because we are better people, but because we have been through a process they never had the chance to go through.
This is not an argument against AI or against new ways of working. It is an argument that the knowledge we have built over many years still has a place, and that this place will likely become even more important in the future than it is today.
A quiet strength
Adaptability is not something you talk about much as a developer. It is not a technical skill you can put on your CV or demonstrate in a job interview. But it is perhaps the most important ability a developer can have, because our industry has never stood still, and it never will.
The developers who have done best over time are not necessarily the ones who were most technically gifted. They are the ones who were willing to learn new things, to adapt when the conditions changed, and to find new ways to use what they already knew. That has always been the case, and it applies even more so now.
The future doesn’t look dark. It looks different. And for those of us who have spent years learning our craft properly, that is not a threat. It is an opportunity to use everything we know in new ways. Not by holding on to how things used to be, but by bringing the best of our experience with us into what is coming.
We are not becoming obsolete. We are evolving. And we always have been.