The missing middle: what AI does to the org chart

A few weeks ago someone asked me whether automation in development and engineering would increase the need for developers and engineers, or end them. The changes happening with developers right now are landing on every knowledge job in the building, the analysts, the accountants, the coordinators, the service teams, and every manager wondering what their team should look like in five years. The real question is what AI does to the org chart.

The common narrative is that AI takes the junior jobs first. The graduate, the analyst, the person at the bottom doing the work nobody senior wants. On today’s hiring numbers that answer is right. Stanford’s Digital Economy Lab found a roughly 19 percent relative employment decline for workers aged 22 to 25 in the most AI-exposed jobs since late 2022, while experienced workers in the same roles showed no comparable gap. The Dallas Fed puts the same young-worker effect at 13 percent on separate data, Yale’s Sonnenfeld team has graduate unemployment near 6 percent and rising twice as fast as everyone else’s, and Goldman Sachs counts AI as a net drag of around 16,000 jobs a month. Juniors are wearing today’s hit.

My read is a bit different. What we are seeing today is where AI landed first. I do not think it shows where the damage settles.

AI now gets a junior to mid-level output in weeks or months instead of years. It does not get a mid-level person to the value of a senior domain expert, because that gap is judgment built over years in one domain. So the real impact lands on the middle, caught between juniors who can now match its output and experts it has no faster way to become. Juniors, I think, come out of this better than anyone expects. Deep domain experts come out of it more valuable than ever. The middle gets moved.

Enterprise IT has seen this twice already, with cloud for infrastructure and SaaS for applications. Developers have lived a longer version in public since the 1950s, and every prediction is on the record.

Weeks to mid-level, years to expert

A mid-level salary buys one thing: competent execution. The years of reps that turn a graduate into someone you can hand a known problem and trust to clear it without supervision. AI compresses that climb. It does not compress the next one, from mid-level to senior domain expert.

AI raises the floor faster than it raises anything else. The cleanest evidence is Brynjolfsson, Li and Raymond’s study of 5,179 support agents at a Fortune 500 software company after a generative AI assistant arrived. Productivity rose 14 percent on average and 34 percent for the newest and least-skilled workers. New agents with the assistant were as productive at two months as agents without it at more than six. That is support work, and I have watched it change from the inside, where an AI assistant took a service desk’s deflection rate from 18 percent to 94 percent.

Developers show the same slope. In three field experiments with 4,867 developers, recent hires and junior developers got 27 to 39 percent more done with a coding assistant. The floor comes up, and the rung that sat just above it stops being distinct.

A graduate with a capable agent can reach what used to be mid-level output in weeks and months, not years. The floor comes up.

In the same studies the gains fade as experience rises. The most experienced support agents saw small gains in speed and small declines in quality, and senior developers gained 8 to 13 percent. The researchers suggest the assistant was passing on what the best agents already knew. That gets a new starter to good practice fast. It has little to hand the people it learned from.

What separates a senior domain expert from a competent mid-level operator is judgment, and that is where leaning on AI can make things worse. In a Harvard and BCG trial with 758 consultants, some worked on a task just outside what GPT-4 could do. The ones using it were 19 percentage points less likely to get the right answer than the ones working without it.

The tools do not add much at the top either. METR found experienced open-source developers took 19 percent longer to finish tasks with AI in codebases they knew well, while believing it had made them 20 percent faster.

Pay packets are already moving. Azar, Giné and Sanz-Espín measured what AI exposure does to wages across 138 million US workers: junior pay down 6.3 percent at exposed firms, mid-level pay down 5.9 percent, senior pay holding or rising. The way I read it, junior pay falling furthest is today’s hit showing up in wages. Mid-level pay falling almost as far is the part that lasts, as juniors reaching mid-level output sooner push up into the mid-level pool and supply outstrips demand. Senior pay holds because the tools are not producing more seniors. The study measures wages. On headcount it shows firms shifting more people into mid-level roles, so for now the middle is being squeezed on price and the numbers have not followed.

A barbell, not a ladder

The career model most of us grew up with was a ladder. Junior, mid, senior, each rung earned by accumulating reps. It assumed the way you became valuable was doing the work enough times that you no longer needed watching. AI took most of the time out of the bottom rungs. The top one still takes years.

What replaces it looks like a barbell, and the weight collects at the two ends for different reasons.

The base holds because someone still has to become the next expert. The Atlanta Fed has gone back to Arrow’s “learning by doing” to show that entry-level tasks are how those experts get made. Cutting them is eating your own seed corn. The base is also the cheapest part of the chart to augment.

The apex holds because value goes to what an agent does not have: judgment, accountability, and the domain depth to catch the confident wrong answer. Microsoft’s Mark Russinovich and Scott Hanselman tell the story of an agent that hit a race condition and inserted a sleep call, the classic fix that hides a bug instead of finding it. Someone in the room still has to know that, and know why, in engineering or anywhere else.

The middle is where the premium drains. Juniors and their agents match its output from below, and there is still no quick route to the judgment above. Labour economists have watched a version of this shape since David Autor named the polarisation of job opportunities in 2010, as routine middle-skill work hollowed out while both ends grew. What is new is AI carrying the effect out of routine manual and clerical work and into the knowledge jobs most org charts are built around.

What cloud and SaaS did to IT jobs

Companies used to run what were effectively small data centres in their own offices. A comms room with racks in it, an Exchange server, a file server, backup tapes in a fireproof safe, and a team of network and server engineers to keep all of it alive. It was just what having IT meant.

Then the delivery model flipped. On-premise infrastructure held almost 60 percent of the world’s data centre capacity in 2018. By 2023 it was down to 40 percent, and Synergy Research expects it under 30 percent by 2028. The service did not shrink. More compute runs today than at any point in history. Where it runs, and who runs it, changed completely.

The jobs did not disappear either. They split three ways.

The senior end concentrated where the infrastructure went, and got paid for it. The US data centre industry directly employed just over a million people in 2024, and primary-market data centre vacancy sat at a record-low 1.4 percent. The deep specialists did not lose a career when the office server room died. They followed the servers, and their market got hotter. On the design side, the BLS projects computer network architects growing 8 percent over the decade to 2035 at a median of $134,050. That is about 35 percent more than systems administrators.

The junior end became generalist administrators and the service desk. The in-house role stopped being “keep the Exchange server alive” and became “administer the services we rent”: identity, endpoints, licences, vendors, integrations. That work still needs plenty of people. The BLS projects around 48,700 openings a year for computer support specialists and another 13,400 for network and computer systems administrators, even with both headcounts easing slightly by 2035.

The middle is the rung that got moved. The engineer five years into mastering one company’s SAN zoning and patch windows had a choice: go deep and follow the infrastructure into the providers, or go broad and run the rented estate. Staying put stopped being a career.

The sysadmin title stretches across all of it, from the admin running the rented estate to the expert who went with the servers. The BLS explains its projected 4 percent decline the same way, with some of the work going to developers doing DevOps, some to networks-as-a-service providers, and the routine parts being automated.

The delivery model changed, and the org chart changed with it.

SaaS did the same to applications. The in-house teams that spent years building and patching a customised CRM or ticketing system were the middle, and that work went into the platforms. I ran one of these platforms at enterprise scale for years. The job market around ServiceNow, Salesforce or Datadog splits cleanly in two: administrators and configurators on one side, platform developers and architects on the other, and not much of a ladder between them. These are job titles that did not exist a generation ago, and they are not niche. IDC expects the Salesforce ecosystem alone to generate 11.6 million new jobs between 2022 and 2028.

The two sides are paid very differently. Salesforce Ben’s 2026 salary survey puts a senior Salesforce administrator in the US on a median of $109,000 and a senior technical architect on $165,000, about 50 percent more. That matches what I saw building teams on ServiceNow. The architects sat in a different pay band to the administrators, and a few more years of configuration did not close the gap.

Put cloud and SaaS side by side and the shape is the same. Plenty of juniors, the domain experts paid far more, and the middle moved. The one difference favours the base this time. The cloud took the interesting work away from the person in the office. AI moves capability toward whoever is holding it, and the cheapest hands it lands in are the newest ones.

Developers have been at this for seventy years

If cloud and SaaS are the recent precedents, developers are the long one. No other profession has spent seventy years writing down predictions of its own extinction and then publishing the headcount. I came up through development, and we have been abstracting our own work away from the physical ones and zeros since day one.

Programming ENIAC in 1946 meant physically rewiring it, plugboards and switches, six women reconfiguring the machine by hand. Punch cards abstracted the wiring. The first assembler, in 1949, abstracted machine code into mnemonics a person could hold in their head.

Then came the compilers, and with them the first predictions that programming was about to stop being a job. Grace Hopper’s 1952 pitch was that with automatic programming “the programmer may return to being a mathematician”. The FORTRAN team’s 1954 report promised the language would “virtually eliminate coding and debugging” and let problems be solved for less than half the cost. John Backus admitted decades later the team had been “hopelessly optimistic”. COBOL arrived in 1960 written to read like English so the code would make sense to people who were not programmers. Then C in 1972, C++ in 1985, Java in 1995, C# in 2000, each layer lifting the work further from the hardware, each one making a single developer far more productive than the generation before.

If making developers more productive reduced the need for developers, the count would have been falling for seventy years. It went the other way, hard: an estimated several thousand US programmers in 1958, then 161,337 in the 1970 census, around 519,000 by 1988, about 1.7 million US software developers on the 2024 BLS count, and 47.2 million developers worldwide.

Every layer made code cheaper to produce, and the world responded by wanting immensely more code.

The BLS is currently projecting both halves of the next turn at once. Software developers, a line that also bundles in QA analysts and testers: growing 10 percent over the decade to 2035. Computer programmers, the occupational code closest to purely typing the code: declining 7 percent. The title nearest the keystrokes shrinks while the title nearest the system grows.

The economics underneath are the ones I keep coming back to. Make production cheaper and you get more of it, not less, the pattern that ran from email and office paper to app stores. Jevons worked this out in 1865 watching coal, and the collapsing cost of intelligence is the steepest version of it we have seen. I cannot find a point in software history where cheaper production meant fewer producers.

None of this was really about code. It is about what happens to a job when its production gets cheap, and that is now every knowledge job on the chart. So yes, to the question that kicked this off: I think there will be more developers. I just think “developer” stops meaning what it means today, the same way it stopped meaning plugboards. Swap in analyst or accountant and I expect the same sentence to hold.

More juniors, a different middle

Once things settle, I expect junior roles to increase, and not only in engineering.

The cost side is simple. A junior was always the cheapest person in the building, and they just became the most augmentable one. The expensive part of a junior hire was the long unproductive runway, and AI just ate most of it. A graduate analyst, accountant or engineer with a capable agent can be contributing at what used to be mid-level range inside their first quarter rather than their fourth year.

The pushback I hear is that if a junior covers the old mid-level ground that quickly, you need fewer of them. That would be true if the amount of work stayed fixed, and it never has. Cheaper production making more production has held through cloud, SaaS and seventy years of software, and there is no reason it stops at code. Every corporate function has a backlog that never gets built, full of reports, process fixes and customer call-backs nobody has time for. That is where the new capacity goes.

What thins is the mid-level as we currently define it, the years spent being the reliable executor of known work. The middle job that survives is a different one, owning the exceptions, supervising the automation, and carrying the accountability for what goes out the door. I traced that shift through the support function already, and it looks the same in finance operations, legal review and HR service delivery as it does in engineering. Domain expertise is the other thing that does not lose value. It concentrates, the way the senior infrastructure engineers concentrated into the data centres.

The bottom of the chart widens at the same time, because the tools stopped checking credentials. People who were never developers are now shipping small tools, and people who were never analysts are starting to ship analysis. I am my own test case: Pelaris is a production fitness platform with real users, run by one person and a fleet of agents. A few years ago that would have been a team of five, and none of those job descriptions would have said “prompt a fleet of agents and review what they ship”.

The wage squeeze on the middle is measured, and so is senior pay holding. The middle-first shift and the junior rebound are my forecasts. If they are landing, graduate hiring will turn up before mid-level hiring does.

What it means if you build teams

The instinct, when a tier looks less productive per dollar, is to cut it. With the base that is the wrong call. With the middle, redesign the job and move the people with it.

• Do not gut your juniors, accelerate them. They are the cheapest people to augment and the only way you grow the experts you will need in five years. AI is compressing the apprenticeship anyway, so compress it on purpose: move graduates through the old middle fast, into exception-handling, agent supervision and judgment work. Watch how they use the agent while you do it. In an Anthropic study of AI and skill formation, developers who used AI while learning a new coding library scored 17 percent lower on a skills quiz afterwards than those who worked without it, while the ones who used it only to ask conceptual questions kept their learning.
• Redesign the mid-tier instead of defending it. The mid-level job stops being “execute the routine competently” and becomes “supervise the agents that execute it, and own the judgment they cannot”. The people in the middle do not disappear. The job they were hired for does.
• Hire and promote for judgment and domain, not throughput. Throughput is the cheapest thing in the building now. What is hard to buy is someone who knows when the confident-looking output is wrong, and who carries the accountability when it matters.

The move the machine cannot make

We have watched this movie before. The office server room did not go down fighting. It dissolved into a delivery model that needed different people in different places, and the industry came out the other side bigger than it went in. The same reshaping is coming for the rest of the org chart now, and if seventy years of abstraction layers are any guide, there will be more people doing the work when the dust settles, in roles that would look as unfamiliar on today’s chart as “cloud architect” would have looked in that comms room.

If you are building a team, build for the two ends and move your juniors through the middle quickly rather than leaving them in it. If you are in the middle, the move is the same one the machine cannot make for you. Get to the judgment.

---

Written by Bradley Hunt. For more on AI-first building and enterprise architecture, see the writing index.