The Role of Developers Is Changing. If I Were a Junior Today, I'd Learn Different Things.

I started programming in Notepad.

Later came IDEs — syntax highlighting, refactoring tools, navigation through code. It felt like a huge leap forward. Then autocomplete arrived, and suddenly you didn’t have to type everything yourself.

Today we are entering a world where AI can propose entire solutions.

Looking back, it feels like something deeper than tools has changed. The role of the developer itself might be evolving.

From ChatGPT to AI Assistants

At first it started quite innocently — chatting with ChatGPT. To be honest, in the beginning it wasn’t particularly good at programming, but it was still incredibly useful. Within seconds you could discuss several possible approaches to a problem. Soon AI assistants started appearing directly inside IDEs, able to generate larger parts of code. You were still writing software yourself, but now you had something that felt like a thinking partner sitting next to you.

Gradually I Stopped Checking Every Line

At some point I noticed a shift in the way I worked. At first I wrote code and verified it in the IDE. Later I spent more time in the terminal and only checked the results in the running application. Some changes I started reviewing only during code review. And when I began using tools like conductor and running multiple tasks in parallel, it became clear that I simply could not follow every detail anymore.

Today another shift is happening. More and more often my workflow looks like this: describe an idea to AI → run it in a test environment → give feedback or ship it. It is a different way of working — less typing, more thinking.

From Autocomplete to a “Software Factory”

Recently I read an article by Dan Shapiro describing five levels of working with AI in software development, comparing them to levels of autonomous driving systems. At Level 0 you write every line of code yourself. At Level 2 AI acts as a colleague working next to you. At Level 4 the role changes significantly — you stop acting purely as a developer and start behaving more like a product manager, describing the specification while AI implements it and you review the results. At the very top is Level 5, what he calls a “dark factory”: specifications go in, software comes out.

When I read this description, I realized I had moved through these stages almost naturally over the past few years. First autocomplete, then AI as a thinking partner, then agents solving entire tasks in parallel. Today I often operate somewhere around Level 4 — I describe the intention, verify the result in a testing environment, and provide feedback.

Maybe AI is not just writing code faster. Maybe the entire process of creating software is changing.

Languages Are No Longer the Most Important Thing

This might be the biggest shift of all. In the past the programming language itself felt extremely important. Today understanding principles matters much more.

Right now I rarely spend much time deciding whether a project should use React, Vue, or Solid. Instead I describe the requirements: the system should be fast, efficient to operate, and deliver the UX I expect. AI can suggest the tools. But for those decisions to be good, I still need to understand the underlying principles — things like observer patterns, caching strategies, or different rendering approaches. Frameworks change constantly. Those principles do not.

If I were starting as a junior developer today, I would focus much more on these fundamentals than on mastering a particular library. Not to write perfect code, but to be able to challenge decisions and understand trade-offs.

Responsibility Has Not Disappeared

AI can generate large parts of a solution today, but it carries no responsibility.

Recently I needed to consume a third-party API. AI suggested a solution where the API would be called directly from the client. It looked functional, but it would expose the API key and quickly hit rate limits once traffic increased. The architecture had to change — instead we introduced a backend layer that fetches the data, stores it, and serves it through our own API with caching in front. AI generated the code for that solution quickly and correctly, but the architectural decision still had to come from a human.

Because AI does not carry the reputation of the product. It does not carry responsibility for security. And it does not face the consequences when something goes wrong. We do.

The New Role of the Developer

This is probably the next step I am learning myself — letting go of the need to control every line of code and embracing the role of someone who provides context, challenges solutions, and ultimately takes responsibility for what gets built.

Technology has changed many times. Notepad, IDEs, autocomplete, AI assistants. But one thing remains the same.

Software is still created by people.

Just in a slightly different way than before.