When AI Writes the Code: How Is the Developer’s Role Changing?

To some extent, yes. A developer can assign parallel tasks to several agents and spend much less time writing code themselves. This is how I work today. I still develop software, but I have barely written a more complex line of code myself for quite some time. AI helps me with implementation, while I focus much more on what needs to be built, how it fits into the system, what the architecture should look like, and whether the result actually meets the user’s needs.

That does not mean that programming knowledge is becoming less important. Quite the opposite. To be able to direct and assess AI-generated outputs, I need to understand what the AI is doing. AI shortens the path to implementation, but not the path to understanding.

I would not say, however, that the developer is becoming merely an AI manager. Rather, the role is shifting closer to architecture and business. Developers need to break a problem down correctly, define the boundaries of the solution, and assess the result in the context of the entire system.

And context is exactly what still does not work as smoothly as it does in demos. AI can solve a specific task very well. What is much more difficult is ensuring that hundreds of such individual solutions come together to form a system that makes sense as a whole.

A code review alone is not enough. The developer needs to understand the business process and what the user actually needs. They have to run the application, go through specific scenarios, and sometimes simply look at it from the user’s perspective. A technically correct implementation does not automatically mean that the solution itself is right.

This is exactly where I believe the importance of an experienced developer is growing. AI can help create a solution faster, but a human still needs to know what to verify and why.

I can already see this happening in real-world projects. AI is capable of producing far more content than a person can realistically read.

I have come across projects where one AI generated documentation, another reviewed it, a third created additional documents from it, and the code was then produced based on those documents. At that point, a person no longer had a realistic chance to go through the entire chain, and sometimes did not fully understand it either.

There is no point in generating a document simply because creating it “costs nothing.” We need to know why it is being created, who needs it, and what information it is supposed to convey.

Perhaps we are reaching a point where our main limitation is no longer the ability to create something, but the ability to understand everything we create.

The role of the junior developer will definitely change. One person using AI can now genuinely do work that used to require several people.

At the same time, however, the cost of creating software is falling significantly, which means companies can pursue projects they previously did not have the capacity or budget for. That is why I do not think we can simply say that fewer developers will be needed.

The bigger question, in my view, is how future senior developers will emerge if AI takes over a large part of the work that juniors traditionally learned from. Today’s “senior” developers also started out as juniors, and becoming experienced developers required countless hours of work, trial and error, dead ends, mistakes, and accumulated experience.

Not by the amount of code they bring to the interview.

I would ask why the solution looks the way it does. What other options were considered? What would they change? Where do they see the risks? What happens if the requirements change?

It becomes clear very quickly whether someone used AI as a tool or simply brought in an AI-generated result they do not actually understand.

And I believe this will become increasingly important in education as well.

In my view, banning AI does not make sense. Students will use it in practice, so they need to learn how to work with it during their studies. But I have already seen AI-generated outputs that students did not understand at all and that, in the end, did not even make sense.

I teach at a university, and this is where I see one fundamental issue for the future. In my classes, I try to show students key architectural principles and encourage them to try solving a problem on their own first. To write something, make a mistake, look for it, and understand what it means to debug, what it means to design an algorithm, and what it means to design a solution, an integration, or an architecture.

This creates a paradox: AI itself tells us that it makes mistakes, that its outputs need to be critically reviewed, and that we need to understand them. Students, employees, everyone needs to be reminded that responsibility for the output does not lie with AI, but with the person who created the prompt and accepted the result. But how are students supposed to recognize a mistake if they have never solved a similar problem themselves?

Yes, we should teach students to use AI. At the same time, however, we must keep emphasizing that they need to develop their own experience and critical thinking, and that they need to understand the problem itself as well as the underlying architecture.

I would not focus primarily on which programming languages the programme teaches or whether it includes a course on AI.

What matters more is whether students are taught to understand the system as a whole: architecture, algorithms, data, security, business processes, and working with users. At the same time, they should also learn how to use AI in practice.

In my view, a school needs to do both: teach the fundamentals and prepare students for an environment in which AI will already handle a significant part of the implementation.

To a large extent, yes. AI can write code, create tests, perform reviews, and then fix errors. And these capabilities will continue to improve.

The problem is the assumption that this automatically leads to the right solution.

One AI can review the output of another AI, but both may be working from the same flawed assumption. They may verify the technical side of a solution very well while completely missing the fact that the solution as a whole does not make sense from the user’s or the business perspective.

That is why, in my view, it is not just about using the “right AI tools.” It is about knowing where we can hand work over to them, what still needs to be checked, and where a human has to make the final decision. And that is largely a matter of experience.

Perhaps this is the biggest change AI is bringing to software development: we can create more and more things, very quickly. That makes it all the more important to know which of them are actually worth creating.