This is not an article about whether AI is good or bad. This is an article about what already happened.

Over the last 18 months, every unwritten rule that ran the software industry for 50 years broke. Nobody voted on it. Nobody announced it. Most people are still arguing about whether the changes are real, while the ground underneath already shifted.

The junior pipeline did not collapse. It was deleted.

This is not a hypothetical. This is not a warning about the future. This is measured data from payroll systems covering millions of workers.

Big Tech new graduate hiring is down 52% from 2019 levels. Recent computer science graduates now have 6.1% unemployment, worse than the 4.8% average for all university graduates. 37% of engineering managers report they would rather use AI tools than hire an entry level engineer.

The critical point everyone misses: this is not malice. This is not greed. This is every single manager running the exact same correct spreadsheet. A junior hire costs $120k/year plus 30% of a senior engineer's time for 18 months before they become net productive. An AI coding assistant costs $19/user/month. It is productive this afternoon.

Every individual decision is rational. The collective outcome is suicide. There will be no seniors in 2032 because there are no juniors today. You cannot backfill experience. You can raise a salary band in one budget cycle. You cannot raise 7 years of scar tissue.

Employment now splits cleanly by age

This is the most disturbing chart nobody is talking about. Pulled directly from Stanford's analysis of ADP payroll data covering 12 million US workers:

Age group	Employment change 2022-2025 (software roles)
22-25	-16%
26-29	-3%
30-34	+7%
35-39	+9%
40+	+12%

This is not a recession. Recessions do not check your birth year. This is AI adoption sorting the workforce exactly along the line of who already has accumulated judgment, and who was supposed to be accumulating it right now.

The grunt work was the curriculum

Nobody liked writing CRUD endpoints. Nobody liked tracing stack traces for three days. Nobody liked fixing the stupid bug in the legacy import script that only broke on Tuesdays.

We called it toil. We called it dues. We celebrated when AI ate all of it.

We did not notice that this work was not waste. It was the training program. An apprentice electrician does not spend three years pulling cable because the master cannot do it faster. They pull cable because that is how you learn how buildings actually work before anyone lets you near a panel that can kill you.

We gave the cable pulling to a robot. We still have working buildings. We just stopped producing electricians.

Vibe coding died exactly when it got good

Vibe coding was fun. Prompt, generate, copy, run, error, repeat. For three months it felt like we had unlocked creative mode. Then everyone tried to build something larger than a weekend prototype.

It turns out you cannot negotiate with an AI for 17 rounds about a button color without breaking authentication. You cannot have a 40 message chat thread without the model forgetting half the requirements. You cannot clean it up later. You never clean it up later.

The endgame was not a better model. It was not better prompts. It was writing specifications before you ask for code. The more capable AI becomes, the more valuable clear thinking becomes. We did not evolve past software engineering. We just moved it one step earlier in the process.

We have been asking the wrong question about AI code

For two years every argument about AI generated code has started with "did you write this or did the AI?".

This is a useless question. It has always been a useless question. We did not ban compilers because people stopped writing assembly. We did not ban ORMs because people stopped writing raw SQL. We did not ban Stack Overflow because everyone copies code.

The correct questions have never changed:

• Can you explain every line?
• Will you fix it when it breaks at 2am?
• Will you maintain it in six months?
• Can you tell when it is lying?

These questions work exactly the same for code written by a junior, a senior, or Claude. Everything else is gatekeeping.

MCP and Skills: the new stack nobody told you about

If you are still pasting code from ChatGPT into your editor you are already two generations behind. Modern AI coding does not work that way anymore.

MCP is not a competitor to Skills. MCP is the wrench set. Skills are the instruction manual that tells you when to use which wrench. This is the dominant architecture right now. Almost nobody is writing about it. Almost every serious team is building it.

The hottest programming language in 2025 is well structured markdown.

The ceiling no one talks about

All of this progress, and there is still one thing no model can do. It cannot make the jump.

Models are very good at deduction. They are very good at induction. They cannot do abduction. They cannot look at a surprising result and infer an entirely new rule to explain it. They cannot resolve a contradiction. They cannot look at two conflicting bookmarks from 7 years apart and work out what you actually believe.

A model trained on every paper ever written about Newtonian physics will produce perfect Newtonian predictions. It will never invent general relativity.

This is not a scaling problem. This is not something that will be fixed with 5 trillion more parameters. This is a fundamental difference in how these systems work.

Productivity gains are real, and so is the cost

Google fixed more security bugs in Chrome during June 2026 than they fixed in the entire preceding two years. Microsoft patched 570 flaws in a single Patch Tuesday. This is not marketing. This is raw output.

Nobody is arguing that AI does not make existing engineers dramatically more productive. The argument is about what happens when you remove the only known mechanism for producing new engineers.

The commons is already gone

This is the part no one wants to say out loud. We have a classic tragedy of the commons, and the lag is what makes it lethal.

The juniors not hired in 2025 are the mid levels that will not exist in 2028. They are the seniors that will not exist in 2032. No company will feel this pain for another six years. By the time it shows up in hiring metrics it will be 15 years too late to fix.

There is no market solution for this. No individual company has incentive to be the one running the apprenticeship. Everyone will continue to free ride on the existing pool of senior engineers until it runs dry.

What you can actually do

If you are early in your career: Struggle first, prompt second. Give every problem 45 minutes of honest effort before you open the assistant. The struggle is not inefficiency. It is the mechanism that writes the lesson into your brain.

Read every AI generated diff like you wrote it. As far as git blame, production and your team are concerned: you did write it.

Do some things the slow way on purpose. Trace the framework call once. Write the migration by hand once. You are not being a purist. You are doing reps.

If you lead a team: Hire one junior. Not for throughput. Not for charity. Hire one junior with a mentor, a rotation plan, and zero expectation they will ship anything useful for 12 months. That is the only investment that will matter in five years.

Keep the instructive tickets human. The gnarly little bug that forces someone to read the whole system? That is tuition. Do not spend it on the model.

Closing

Nobody voted for this. Nobody planned it. One perfectly rational decision at a time, we automated the thing that produced the people we rely on.

AI did not kill software engineering. It just stripped away all the parts that were never actually engineering. The typing, the boilerplate, the memorization, the syntax trivia. All that is gone.

What is left is the actual work. Thinking clearly. Defining problems. Evaluating tradeoffs. Taking responsibility. Judging what is good enough.

That part never got easier. It just got more important.