https://cra.org/crn/2025/08/infographic-computing-bachelors-...

EDIT: it's also hard to account for the fact that job position titles aren't very consistent over time and I know quite a few new grads who got "senior" job positions

ZIRP ending, coding becoming a full blown meme ("day in the life of a wfh swe" videos on tiktok), and work from home exploding.

This combination of factors made it risky to make a mistake hiring an unqualified SWE. SWE salaries exploded AND money got more expensive. At the same time, the number of unqualified applicants exploded due to the EZ bootcamp wfh 6 fig meme, and on top of this, remote interviewing made it very easy to cheat your way into a job you were not qualified for. Since it's very difficult to gauge quality of SWE talent, this pushed companies very strongly in the direction of hiring senior talent. Of course, companies and managers do not want to announce that they do not know a good engineer from an awful one. So here comes a convenient excuse, the excuse that companies make for everything nowadays: "AI".

The article is correct though. This explosion in interest in CS, along with very powerful AI tools, has produced a very strong batch of junior engineers that are very very underpriced relative to their senior colleagues. If I were running a company right now and needed cheap, strong talent, there is never a better time than now. Recruit and hire exclusively junior engineers -- and only interview in-person.

As a long time SRE/DevOps, this is the key point that I believe people are overlooking in the "AI will let anyone write code!!"

Support does not scale linearly with additional software. If anything, it grows faster due to the "two systems == one connection, three == three connections, four == six connections" etc.

Sure, you could argue that LLMs could ALSO do the support but the reason you have people around to begin with is for when the technical systems break in weird and interesting ways. Similar to how planes have pilots even in the age of autopilots (the humans are, of course, still fallible).

Another argument might be: well, LLMs will write better software. My counter is that there weren't really excuses for not writing better software before but we still got buggy code with poor documentation. If anything, LLMs will make it easier to crank out barely maintainable and supportable code at even faster rates.

- Junior developers become senior relatively quick. Most senior developers get their senior title just a few short years into their careers. Typically in their late twenties or early thirties. Not judging but that seems to have been the state of affairs in software engineering for quite some time. I was a "senior" by age 30. I've learned a lot since then ;-).

- AI is increasing the demand for software because software just got cheaper to make so people want more, not less. The best software still gets made by senior people (with or without AI). That's why seniors are in demand. That should have an effect on their compensation. Which would be very welcome given the last few years of freelance rates dropping.

- Software creation is a team sport. Having a team mainly consisting of old and grumpy middle aged software engineers isn't necessarily the best thing (been there done that). It might be better to have a mix of young old and experienced/inexperienced. There's plenty of room for juniors in the industry.

- Juniors come in many forms. Some people have a lot to learn. Some people create valuable startups straight out of college.

- Software companies that are not constantly investing in their staff will have to deal with replacing their older staff as they move on, retire, or disappear for other reasons. A constant in flow of juniors that you can then train up and turn into valuable team members still works just like it always has.

- Juniors are a lot cheaper to hire than seniors. If there's a shortage of seniors, hire juniors instead and then train them up. That's what many companies were doing anyway. If anything a lot of silicon valley companies seem to have been preferring to hire juniors almost exclusively for quite some time.

- As long as the amount of programmers keeps on growing (and there are no signs of that slowing down that I know of), there will be more juniors than seniors. I'm not sure if the amount still doubles every five years but that seems to have been true for a long time.

- Companies should hire juniors [at their own perceived detriment] to improve the overall industry

- Hire juniors because strong companies are resilient to junior mistakes [rather than hiring seniors and also becoming resilient]

- Juniors learning fast inspires others

- Juniors will teach your seniors how to use AI

Perhaps you can see why most companies don't find these terribly compelling.

Personally, I suspect we're going to have to wait for capitalism to fix this. Senior engineers will age out and the supply will drop. This will increase the cost of seniors until low-cost juniors start to look like a better option to the median hiring manager.

This just became another boomer rant. Complete garbage.

We are in a transition phase and the standards to be employed are going up.

The best new grads and juniors will come to see AI as a “code generating machine” and “answer machine” and upskill themselves then come in at what we currently call mid level.