I often hear: If AI writes the code, we no longer need architects. In the projects I see the opposite every day.
The claim I hear often
The logic goes like this: A modern model knows every design pattern. It can implement Strategy, Factory, Adapter, all of it cleanly. It knows every library, every framework, every best practice. So it can do the architecture too.
The first part is true. The second is not.
Fact is: implementing a pattern is not hard. The hard question is: Where do we need which pattern, and why? And how do we make sure that this decision holds across the whole system, not just in the module the agent happens to have in front of it?
What an agent sees and what it does not
A coding agent sees its task. A ticket, a few files, maybe the repository. That is a lot, but it is not the system.
It does not know that we already solved this problem six months ago somewhere else. It does not know why an interface looks the way it looks. Why certain data must not flow directly between two systems. Why in one place we deliberately do not want a new dependency, even though it would be easier.
It is no different with people, by the way. A new developer, however good, does not know the reasons either. The difference: He asks. An agent builds.
The most important answer is no
What has surprised me most in the last few years: The most valuable decision of an architect is, more and more often, that nothing gets built at all.
New code used to be expensive. Someone had to write it, test it, review it. That slowed things down, and the brake was healthy. Today an agent produces a thousand lines in minutes. The ballast does not stand out at first, because it costs nothing. It only costs later, when someone has to understand it.
So it takes someone who says: No. That already exists. No, that does not belong here. No, we do not solve this problem with code, but by changing the requirement. A model cannot do that today, because it would have to know the whole system for that.
Putting knowledge into a form
The architect's work is still changing. And in a direction I like.
Architecture knowledge used to live in heads. The one who has been around for ten years. The other who knows why the database is structured the way it is. When they leave, the knowledge leaves with them.
Today this knowledge has to go into a form that agents can work with. Rules an agent can read. Contracts it builds against. Checks that run automatically. That is work, and it is exactly the work that good architects always wanted to do and never had time for.
At NeoCoder this is the core: An architect agent writes the specification and contract before anyone touches code. But the architect agent gets its rules from a human. And this human has become more important, not redundant.
The new role
The architect no longer explains to the AI how to write a class or build an endpoint. He leads the system.
He defines architecture and rules. He decides which patterns apply where. He makes sure that five agents do not build five solutions for the same problem. He brings domain knowledge into a form that AI can work with. And he decides when the AI is wrong.
That is a bigger role than before, not a smaller one. And there will be fewer people filling it. Five humans with twenty or fifty agents. But those five have to know very precisely what they are doing and where they want to go (system goal).
Code is becoming a commodity. What stays is the decision about what gets built, what does not, and why. That is architecture. And it is not dying out. It is only now becoming really important.
Written by me. The thoughts, the values, the learnings, the mistakes: all mine. Grammar and spelling are corrected by our own twin model, trained on my texts. Sometimes a stumble stays in. That is mine too.