We Must Preserve the Engineering Development Chain
There is another problem that is rarely discussed seriously enough.
Software engineering has a development chain.
That chain looks approximately like this:
Training
↓
Internship
↓
Junior Engineer
↓
Mid-Level Engineer
↓
Senior Engineer
↓
Technical Lead
↓
Technical Principal
↓
Architect
You cannot permanently remove one part of that chain and expect the rest of it to continue existing. There are no new architects without new senior engineers. There are no new senior engineers without new junior engineers. And there is no architect in the world who somehow appeared at the architect level without previously going through earlier stages of development. Every architect was once a junior. Every senior engineer was once a junior. Every experienced engineer once had questions that today may appear completely basic. That is how technical development works.
A junior engineer is not simply a cheaper version of a senior engineer.
A junior engineer is a future senior engineer in development.
If companies stop hiring and training junior engineers because they believe AI can perform the simpler parts of their work, they are not solving the problem. They are postponing it. For several years, everything may appear completely fine. Existing senior engineers still exist. Architects still exist. Technical leads still exist.
The organization continues working. But then time passes. People leave. People retire. People move into management. People change industries. Some stop working completely. And suddenly the organization discovers that it has created no new generation capable of replacing them.
The pipeline has been broken. The situation then looks like this:
Existing Architects
Existing Seniors
↓
↓
↓
No new Juniors
↓
No new Mid-Level Engineers
↓
No new Seniors
↓
No new Architects
You cannot solve that problem later by simply deciding:
Now we need more senior engineers.
Senior engineers are not manufactured in six months.
Architects are not created by changing someone’s job title.
Technical depth requires years of:
- implementation;
- debugging;
- failure;
- production incidents;
- bad decisions;
- good decisions;
- refactoring;
- migrations;
- system design;
- maintenance;
- learning from more experienced people.
That process cannot begin if there is nobody at the beginning of the chain.
Junior Work Is Part of the Training Process
Another mistake is to look at junior-level work and conclude:
AI can do this task, therefore we no longer need juniors.
That completely misses the point.
Some tasks given to junior engineers are not important only because the organization needs the task completed.
They are important because the engineer needs to go through the process of completing them.
There is a major difference.
A junior may spend hours understanding:
- why a test fails;
- how an HTTP request works;
- why a database query behaves differently;
- how a race condition appears;
- why a process cannot open a file;
- why an interface was designed in a certain way.
A senior engineer may solve the same problem in ten minutes.
An AI agent may generate a working answer in several seconds.
But the junior’s purpose is not merely to compete with either of them on speed.
The junior is building the mental models that will later allow them to solve much larger problems.
If AI removes every small problem before the junior has the opportunity to struggle with it, investigate it, understand it, and finally solve it, then we may be removing part of the mechanism through which future expertise is created.
The output may appear faster.
The engineer may develop more slowly.
Those are two completely different measurements.
Someone Has to Train the Next Generation
Engineering knowledge does not transfer automatically. Someone has to:
- review code;
- explain mistakes;
- show alternatives;
- explain why a solution is dangerous;
- demonstrate debugging;
- teach system thinking;
- expose less experienced engineers to real problems.
That responsibility usually belongs to people further along the development chain.
A healthy engineering organization therefore has something like:
Architects
↓ mentor and guide
Senior Engineers
↓ mentor and guide
Mid-Level Engineers
↓ help and guide
Junior Engineers
But knowledge also moves upward. Junior engineers ask questions. They challenge assumptions. They encounter problems from a different perspective. They force experienced engineers to explain decisions that may have become automatic after many years. A healthy technical organization is not simply a collection of isolated experts.
It is a continuous transfer of knowledge between generations of engineers.
AI Cannot Be Allowed to Break That Chain
AI can absolutely become part of that development process. It can:
- explain concepts;
- provide additional examples;
- generate practice tasks;
- assist debugging;
- reduce repetitive work;
- provide another perspective.
But it should not become an excuse for removing the beginning of the engineering career path.
If the industry reaches the conclusion:
AI can perform junior tasks
↓
therefore we stop hiring juniors
then several years later the same industry may discover:
we cannot find enough seniors
And several years after that:
we cannot find enough architects
At that point, the cause should not be difficult to understand. The chain was broken at the beginning.
There Is No Shortcut to Experience
Experience is accumulated. You cannot prompt your way into ten years of production experience.
You cannot skip [Junior/Mid-Level/Senior] and simply become [Architect],
because an AI model can generate architecture diagrams and code.
An architect needs to understand the consequences behind those diagrams. A senior engineer needs to recognize why something that appears correct today may create a serious problem two years later. That ability comes from accumulated exposure to real systems.
And that exposure begins somewhere. Usually, it begins with small problems. Junior problems.
Tasks that look insignificant to an architect today but were once necessary steps in that architect’s own development. Do not forget that.
There is no architect who was never a junior.
If we want future senior engineers, we need junior engineers today.
If we want future architects, we need future senior engineers.
If we want software engineering to remain a serious profession, we have to preserve the complete development chain.
AI can become part of that chain. It should not be allowed to destroy it.