Code is cheap nowadays, people say. And indeed, agentic coding support makes building a large software system much faster. When done right, of course. In my previous article, I looked into the effects of a naïve approach to agentic coding.
Traditional software teams in larger enterprise projects often followed a pyramid organization: a few seniors in responsible roles on top, and maybe 2/3 mid-level and junior engineers. The press has written a lot recently about how AI is reshaping the entry-level job market. In the last few days, there was an announcement that Microsoft plans severance offers for 60.000 employees, mostly in the technical parts of their business worldwide.
Today I want to look at what others say about what modern engineering teams look like. I also want to tackle the uncomfortable question: When AI replaces entry-level jobs, how do we get the seniors needed to run the agents?
Effects seen today
Quite a few articles and studies have been published recently from players like Bain & Company, Gartner, or McKinsey.
They largely come to similar conclusions.
Team Size Compression
McKinsey say that in top-accelerating organizations (in terms of agentic coding), 79% of the organizations they interviewed reported that squad size decreased. The median of the survey was a reduction from about 10 to 7 members. Bain reported that in their survey teams shrunk to “pods of 3-5 people”, with routine execution roles disappearing.
Gartner thinks the total number of teams will increase to meet growing business demand, but with what they call “tiny teams.”
The Seniority Inversion
Bain see the traditional pyramid in organizations flattening rapidly: “Fewer engineering organizations report traditional pyramid structures, down from 66% to 29%. Fluency with AI tools is now the leading capability sought out in engineers; cited by 62% of survey respondents”.
The effects of this is obvious: When fewer entry-level jobs are created, how to find or train the seniors the companies desperately need?
“Companies need more senior judgment than ever, yet they are quietly dismantling the path that produced it.” — Bain, 2026
The routine coding, debugging, and testing tasks that junior engineers historically learned on are precisely the tasks agents now handle. Without deliberate intervention, the supply of future senior engineers is threatened.
The junior talent pipeline crisis might even influence whether young talent decide for computer science at university, enforcing the shortage even more.
Emerging and Evolving Roles
Companies Forrester or Thoughtworks describe that new roles appear in organizations:
AI Engineer / Agent Reliability Engineer: Manages agent tooling, configures coding assistants, builds agent workflows, maintains evals that catch agent-generated bugs
Knowledge Architect: Designs and maintains the shared knowledge layer (memory, context) that agents consume
Agentic Architect: Designs the multi-agent system architecture and orchestration patterns
AI Conductor / Orchestrator: Guides agents, composes workflows, enforces guardrails — the “manager of AI agents”
Evaluation/Governance Engineer: Builds policy-as-code, audit harnesses, and compliance validation for agent outputs
Traditional roles like developer, UX designer will be shifted towards directing agents. In general, the expectation is that job boundaries start blurring significantly and team members take on a broader range of tasks.
Bottleneck Migration
While traditional projects very often had code production as their bottleneck, other roles will be in focus: Product Managers will much more rapidly have to decide on the product direction and design, while quality assurance and code reviews need to keep up with the new development speed. As more products go into production, decision-making and accountability will be the next challenges to solve.
Facing the talent pipeline crisis
So, what’s the best way to find seniors for the new age of agentic coding? Obviously, you can try to recruit on the free market. I expect seniors who meet modern skill requirements will see their salary expectations go through the roof for good reasons. They will be key players in modern teams and key to the velocity multiples companies expect.
At my former company, we recruited working students early in their university careers and taught them our technology stacks. But it still comes down to how you select talent and what opportunities you give them to learn in real-world situations. We were a smaller company, so we were used to taking on a broader range of responsibilities than employees in large organizations typically do.
Everyone knows one or more young talents who seem to become senior overnight and absorb new technologies like fresh air, while others need intensive training on every new piece of technology.
Of course, a few are natural, usually identified by how they talk about their personal IT projects during interviews. Or the speed and enthusiasm with which they approach a challenge.
But to grow not only those, but also talent who aren’t geniuses, you need an environment to learn. When we asked people what they enjoyed most, they said it was good old “boxes and arrows”: discussing architecture and design problems on a whiteboard with a senior team member. Just to see the train of thought senior developers take. Finding new ideas and aspects that come from years of experience. Showing persistence in complex troubleshooting situations. Learning new tools and how to track down problems at the intersection of infrastructure and code.
And sometimes it’s just as simple as trying to be a good role model for colleagues. In the end, we are all human beings and appreciate mutual respect. As my colleague always said: “Employees work for other people, not for companies.”