AI didn’t take the junior job. It took the bottom rung.

I’ve been turning this over for months, and I’m still not sure I have the cleanest version of it. So read this as field notes rather than a verdict.

I run a coding school, which puts me in a slightly odd seat. I see who walks in the door and what they already know. I also see what employers expect a new developer to do in their first month. There has always been a gap between those two things. What’s new is that AI is making it wider, and it’s widening in a place most people aren’t looking.

Here’s the short version. There was an unwritten deal behind most software careers: university teaches you the theory, and your first employer teaches you the job. Nobody signed it, but everyone relied on it. Junior roles were where the trade got taught. And the work those junior roles were made of is exactly the work AI is now best at.

Knowing things versus doing stuff

A computing degree is organised around subjects. A semester of data structures, a semester of databases, a semester of networking, each with its own exam. That’s how the credit-hour system works, and it’s good at one thing: proving you covered a topic. It’s much worse at proving you can make the topics work together, because nothing in the structure forces you to.

A software job is the opposite shape. On day one nobody asks which chapter you’re on. They hand you a running system: a couple of front ends, an API, a database, a login flow, a payment provider, a partner integration, logs, a deploy pipeline. Your first ticket touches four of those at once.

And most of that work is closer to a trade than a science. Every company runs on its data, and a huge share of software just moves that data around reliably: the confirmation email, the call to a partner’s API, the dashboard finance reads every Monday, the thing that broke at 2am. Understanding data structures matters, because you should pick the right one. Hand-writing a hash map for an exam matters much less, because every language ships one.

Where the degree still earns its keep

I want to be fair to universities here, because the lazy version of this argument is wrong. Theory is not useless. Complexity, how memory actually works, statistics and linear algebra all matter, and they matter more if you head towards machine learning. Some employers still filter hard on a degree, and many visa routes require one. The people who go deepest in this field, the ones writing databases and compilers, mostly came through a computing degree.

So if you hold one, you haven’t wasted it. It’s a floor, and I’ve written about how to build on it separately. My argument is narrower: for most people who simply want a job building software for a company, the degree was never the whole training. Employers quietly did the rest. That “rest” is the part that’s disappearing.

You can see the gap in who signs up to learn with us. These are enrolled, paying students, not curious browsers.

The number I keep coming back to is the 27%. More than a quarter of that sample had already studied computer science or IT, and still paid for a second education. I can’t tell you every one of their reasons. But people rarely pay twice for something they believe they already have.

The Malaysian version of the problem

Here the gap shows up in a specific way. It isn’t mainly unemployment: graduate unemployment was 3.2% in 2024, close to a decade low. It’s underemployment. In the third quarter of 2025, 35.5% of employed degree and diploma holders were working in roles below their qualification, and for the youngest graduates it was two in three.

That pattern is exactly what you’d expect when the first rung is thin. Young graduates take whatever job they can get to “gain experience”, and the experience they gain often isn’t the kind that leads back to the career they studied for. Now take the routine developer work that used to be the on-ramp and hand a large share of it to AI. The on-ramp gets narrower at the precise moment more people are trying to use it.

How juniors used to become seniors

Whether a new hire came from a university, a bootcamp or nowhere in particular, the path from junior to senior looked roughly the same. You were hired with gaps. You were given the work the seniors didn’t want: fix the validation on this form, add a field to that endpoint, rename something across forty files, write tests for the module nobody tests. A senior reviewed it and sent it back covered in comments. You got slightly better. The tickets got slightly harder. Repeat for a few years and, somewhere in there, you developed judgement.

The economics worked for both sides. A junior costs less than a senior, and after a year or so there’s a sweet spot where they produce more than they cost. Companies tolerated the gaps a graduate arrived with because the routine work was a safe, cheap place to close them.

Here’s the uncomfortable bit. Those routine tickets are exactly what AI coding tools are best at. In Stack Overflow’s 2025 survey of more than 49,000 developers, 84% said they use or plan to use AI tools (figures collected in our AI hiring report). When a senior can get a first draft of that endpoint in under a minute, the case for hiring someone to do it slowly for a year, so they can learn, is harder to make in a budget meeting.

The rung didn’t move higher. It got removed. And it was the rung where the trade got taught.

To be honest about the other side: companies are still hiring juniors, and some are paying a clear premium for juniors who are genuinely fluent with AI. But look at what that premium is paying for. It’s paying for someone who arrives already able to do a chunk of what the bottom rung used to teach. The ask didn’t disappear. It moved earlier, onto the candidate.

What’s left when the routine work is automated

Strip out the drafting and the job doesn’t shrink. It turns into a set of decisions that were always there but used to be reserved for the senior in the room.

Look at that list and ask where a typical degree teaches it. Almost nowhere, because none of it fits inside a single module. Every one of those six is learned the same way: by building whole systems, getting them wrong, and having someone more experienced tell you why.

Why you can’t prompt your way past it

The tempting answer is that AI will fill the gap too. Just describe what you want. The problem is that directing AI well takes context you can only give if you understand the system. Which service owns this data? What’s the permission model? What does “finished” mean here? Leave a gap in your instructions and the model will happily fill it with something plausible. And plausible is the most expensive kind of wrong, because it survives until production.

It’s telling that the same survey found 46% of developers actively distrust the accuracy of AI output. The people who use it most trust it least, because they can see exactly where it slips. You can only see that if you’ve built enough to know what right looks like.

This is why students who lean on AI for the fundamentals are, in my view, widening their own gap. You get good at building systems by building bad ones first. Every decent engineer I know has painted themselves into a corner dozens of times: the database design that couldn’t handle the second feature, the “quick” hack that took a week to undo. That bad first version is the tuition. If an AI writes your first ten bad systems for you, it also keeps the lessons. I made the longer case for this in vibe coding versus fundamentals.

What we changed because of this

A caveat first: I run a school, so I have an obvious interest in the argument that the traditional route leaves a gap. Weigh what follows with that in mind. But these are design decisions we made precisely because of the problem above, and you can apply the same principles anywhere.

Slow first, then fast. Our AI assistant, Sigmo, sits beside every lesson, and it’s built to give hints and ask questions rather than hand over answers. Later in the programme, students direct AI tools through whole features. The order matters more than the tools.

Whole systems, not exercises. Every mission ends in a complete product: a code repository, a live URL and a recorded walkthrough, reviewed by a human. From the middle of the programme, students build and run their projects on their own machines rather than in a browser sandbox, because a developer who can’t run their own project hasn’t learned the job yet.

Defend it out loud. The big milestones are defended live to an instructor who asks why you built it that way. It’s the closest thing we can give to the senior who used to send your pull request back covered in comments, and it’s the one test AI can’t sit for you. The whole syllabus is public if you want to see how it’s sequenced.

I don’t have a tidy ending

I’d love to finish with a neat prediction, but I don’t have one. What I have is a pattern: the gap between what a degree produces and what a first job demands was already there, and AI is multiplying it by removing the work that used to close it.

Employers will keep using degrees as a filter for a while. That is real, and pretending otherwise would be dishonest. But at current costs, I think a degree on its own has become a weak bet for most people whose actual goal is a developer job, and a strong one only when it’s paired with the practical half done deliberately.

Whichever route you take, the order is what counts. Go slowly enough to learn how connected things work. Then go fast with AI. If you want to feel what that first, slower stage is like, the free trial is the first week of it, no card needed. And if you’re further along, read what “AI-native” actually means for a junior, which is what interviewers are now checking for.