Norwegian IT firms are cheering over productivity gains from AI code tools. But behind the numbers, a concern is growing that has so far received little attention: who will fill the senior positions in five to ten years, when we are already stopping hiring — and thus training — juniors?
This is the core of the debate that Digi.no is highlighting, and which more and more people in the industry recognize.
Junior tasks are disappearing — but not the need for them
For many decades, the junior role has functioned as an institutionalized apprenticeship program. The fresh developer was given simple bug fixes, routine CRUD code, and supporting code reviews. It wasn't glamorous, but it was where the foundation was built.
Now, AI assistants like GitHub Copilot, Cursor, and similar tools are taking over increasing parts of precisely these tasks. The result is that the threshold for what a new hire must know from day one is rising dramatically.
When AI does the job that trained an entire generation of developers, who will then train the next?
International data supports this concern. According to research data obtained for this article, the number of job postings aimed at junior developers has fallen by a full 34 percent from peak levels. At the same time, experience requirements are increasing: where two years of experience was previously required, many businesses now ask for three to five years.
AI makes juniors faster — but not necessarily more skilled
It is tempting to interpret productivity gains as an unalloyed good. Juniors using AI tools solve tasks up to 55 percent faster, according to available research. But speed is not the same as understanding.
The core of the danger is that AI-generated code rarely fails in the way that forces a developer to dig deep. The classic errors — pointer errors, memory leaks, subtle race conditions — are precisely where one builds the intuition that distinguishes a good senior developer from a mediocre one.
Mentorship and progressive exposure to real problems are what build competence over time. When businesses stop hiring juniors because AI handles "the simple things," they are simultaneously cutting the pedagogical staircase.
The big picture: Growth and risk at the same time
The situation is paradoxical. Globally, the demand for programmers is growing strongly. The American Bureau of Labor Statistics estimates that there will be nearly 328,000 new positions for software developers in the US alone through 2033 — a growth of 17 percent. And recruiter optimism related to AI rose from 43 percent in 2025 to 55 percent in 2026, according to available industry data.
For Norwegian IT businesses, this is particularly relevant. Norway already has a tight labor market for experienced developers. If one reduces the intake of juniors today because AI takes the simplest tasks, one puts oneself in a difficult situation in a few years — exactly when the need for senior competence is greatest.
What should IT firms do?
There is no single answer, but the discussion Digi.no raises points toward some clear action alternatives for the industry:
Consciously maintain junior positions, even when AI makes it tempting to streamline them away. These positions are an investment in future senior competence, not just cheap labor.
Restructure training paths so that juniors are exposed to complexity early — not shielded from it. AI tools should be introduced as a supplement to understanding, not a replacement for it.
Demand systems understanding already in the hiring process. Candidates who can only use AI to produce code, but cannot explain what it does, are a risk — not an asset.
The question is whether the Norwegian IT industry is willing to think five years ahead, in a sector where quarterly results always compete with long-term competence building.