ALEXSOFT INSIGHTS
Why are senior developers becoming more valuable in the AI era?
As AI writes code faster, experience in deciding what is needed becomes more important. Reflections on senior developers’ roles through healthcare system analysis and business planning.
In my previous article, I discussed why the same AI can produce different levels of work.
The result changes greatly depending on how you explain the work, which parts of the output you identify as problems, and how you direct the revisions.
Writing that article naturally led me to another thought.
“Could this be why senior developers are becoming more valuable in the AI era?”
At first, I found it a little difficult to understand why experienced developers would matter more when AI could write and test code.
But as I kept using AI in real work, the distinction between what AI does well and what an experienced person needs to do became clearer.
AI mainly takes on the execution.
In the past, building a system required dividing the work among many people.
Some analyzed the business and designed the structure; others built screens and APIs; still others handled testing and documentation.
Today, an experienced developer can use AI to do much of this work directly.
The speed of producing code, writing tests, organizing documentation, and comparing implementation approaches is incomparably faster than before.
But doing work quickly and deciding what work should be done are different problems.
I was reminded of that distinction while analyzing the source code of an older business system.
Existing code does not mean a feature is still needed.
The healthcare information system I was examining had been developed with reference to an earlier HIS.
That earlier system had itself been based on an even older HIS for a tertiary general hospital.
Across several generations, much of the previous systems’ functionality and code had been carried forward.
Looking only at the source, some features appeared quite complete. The associated services and data processing logic were there. When I asked AI to analyze them, it provided fairly detailed explanations of their structure and behavior, complete with diagrams.
From the initial analysis, they looked like features that could still be used.
But knowing the system’s background and the actual work raised a question.
Were these features really still needed?
A closer look showed that the logic was based on earlier healthcare regulations and the business processes of large hospitals at that time.
It did not fit the workflow of the current system, and it could not easily be reused with a few changes. Checking the actual call relationships confirmed that these were features the current system had no use for.
AI had not misread the code.
It had answered “How is this code implemented?” quite accurately.
But what we really wanted to know was, “Is this feature still needed?”
Code alone could not answer that question.
We also needed to understand the system’s history, current regulations, actual business processes, and the product’s future direction.
AI broadens the scope of a senior developer’s work.
I had a similar experience while reviewing business direction.
In the past, specialist business management staff usually handled market research, competitor research, and analysis of future business direction separately.
Even as a development project manager, I had areas I knew well and others I did not. When I occasionally had to do that work myself, it could be a painful process.
With AI, I could connect market data collection, competitor comparisons, customer requirements, and technology trend analysis and examine them myself.
Within a day, I could review an area that previously might have taken several people weeks to research and organize, bringing it to a level useful for setting business direction.
That does not mean AI chose the business direction for us.
Deciding which markets to compare, what mattered in the mass of information, whether adoption would be technically difficult, and whether this was an area we could do well still required the development and business experience I had accumulated.
Once AI could quickly provide detailed research and organization, that existing experience became useful across a much broader area.
AI amplifies differences in experience rather than erasing them.
Before AI, there was a clear limit to how much work one person could do, however experienced they were.
Research, implementation, comparison, and documentation all take time. Paradoxically, as people gain experience, responsibilities such as organizational management often increase, leaving even less time for hands-on work.
AI greatly reduces that execution time.
An experienced person can then spend more time defining the problem and setting direction. They can ask AI to do the necessary research, verify the results, and request analysis from another perspective when something is wrong.
As AI becomes more capable, the influence of people who know what to ask it to do and can judge its output grows as well.
So I do not think AI will necessarily narrow the gap between senior and junior developers. In some respects, it may make differences in experience even more consequential.
By “senior,” though, I do not simply mean someone who has worked for many years.
I mean someone who can ask better questions through firsthand experience, understand the context beyond the code, and take responsibility for judging AI’s output.
Does that mean we no longer need junior developers?
From a company’s short-term perspective, one experienced person working with AI may look attractive.
AI can quickly handle much of the implementation and test execution that junior developers used to do.
But in the long term, there is a serious problem: today’s seniors did not start out as seniors.
They built judgment gradually by making small features, making mistakes, experiencing failures, fixing poor designs, and receiving reviews from others.
If juniors have no chance to gain that experience, where will tomorrow’s seniors come from?
As the way we work changes, the way we develop junior talent must change too.
Having them repeatedly write simple code to a predetermined design, as in the past, will not quickly build the capabilities this era requires.
They need to verify AI-generated code themselves, explain why a structure is necessary, and examine actual production outcomes alongside experienced people.
Even within a small scope, they should experience the whole process: understanding business and customer requirements, defining the problem, planning a solution, and developing it into a real product.
What juniors will need is more than experience writing large amounts of code. It is experience understanding a problem, solving it, and taking responsibility for the outcome.
The value of senior developers is changing, not disappearing.
As AI advances, people are writing less code directly.
But deciding what to build, structuring complex problems, connecting technology with business processes and strategy, and checking that the result is right all remain.
AI also makes it faster to move in the wrong direction. A developer with poor judgment can go further down the wrong path.
That makes the person who can set direction and recognize when to stop even more important.
I see AI less as a replacement for a senior developer’s experience and more as a tool that greatly extends the reach of that experience.
Could that be why senior developers are becoming more valuable in the AI era?
Rather than leaving every judgment to AI, I keep thinking about how to combine it with my experience in software development, business analysis, and project management to produce faster and better results.