People keep asking whether AI will wipe out programmers in five years. I think that question is already one step behind. The uglier thing is happening lower down. I keep coming back to one very blunt real-world scenario: a small software shop used to staff a routine business app with a product person, a designer, a couple of front-end developers, a back-end developer, and QA. Then the owner forced the senior people to start using AI for the boring parts. The database models came out fast. The CRUD endpoints came out fast. The form pages came out fast. Even the test skeletons came out fast. A big slice of the junior work just vanished.
That is the part too many people still refuse to say clearly. AI is not mainly killing the idea of programming. It is attacking the old training ground: admin dashboards, internal tools, boilerplate APIs, form-heavy interfaces, test scaffolding, migration logic, and all the repetitive tickets that used to be annoying but useful because they taught people how real systems work. Once that layer starts getting eaten by AI, the profession does not disappear overnight. The ladder does.
The Old Beginner Path Was Never Glamorous
Nobody got into software because they dreamed of building account settings pages or another internal approvals dashboard.
But that was how a lot of people learned.
They learned by handling:
- boring tickets
- repetitive bug fixes
- CRUD screens
- validation rules
- API glue
- admin panels
- test cleanup
- docs nobody wanted to touch
That work was not impressive. It was still valuable.
It let beginners make mistakes on manageable things. It gave them repetitions. It taught them how messy real software actually is once you leave tutorials behind.
That is exactly why I think this moment is so dangerous. AI is landing hardest on the least glamorous layer, and that layer was the apprenticeship system whether people liked it or not.
The Economics Get Brutal Fast
The reason this is moving so quickly is not that the models are magical. It is that the arithmetic is brutal.
If a senior engineer can prompt out a decent first pass for:
- a back-office dashboard
- a batch of endpoints
- a permissions form
- a migration script
- unit-test scaffolding
in the time it used to take a junior developer to settle in, ask questions, and build the first version by hand, management does not see a philosophical debate. Management sees cost compression.
That is why I do not buy the comforting line that "AI still makes mistakes." Of course it does. That is not the threshold that matters. If the senior person can correct the AI output faster than they can mentor the junior person through it, the junior seat becomes much harder to defend.
This Is Why Small Teams Are Suddenly Looking Even Smaller
I think people miss how concrete this already is.
Take a very normal project: a client wants an internal web app with forms, user roles, reporting, and some integrations. A few years ago, that meant handing a chunk of the implementation to juniors because the work was predictable and time-consuming.
Now the conversation changes.
Instead of:
- "let the junior build the forms"
- "let the junior scaffold the API"
- "let the junior handle the test setup"
it becomes:
- "have the senior generate the first pass with AI"
- "review the security and business logic"
- "ship faster with fewer people"
That is not theory. That is a workflow change. And once a workflow changes like that, headcount changes with it.
The Profession Survives. The Beginner Lane Does Not
This is the distinction I wish more people would make.
There will still be engineers.
There will still be hard bugs.
There will still be ugly integrations, security failures, production incidents, weird performance issues, architecture tradeoffs, permission bugs, and business rules that no model understands cleanly from one prompt.
But none of that protects the old beginner lane.
What used to be a training ground now looks, from a manager's chair, like the exact place where AI should save money first.
That is why this is so much harsher than the question "Will programmers disappear?"
No, not like that.
The harsher version is: will companies still pay humans to learn on the work AI now handles well enough?
That answer looks much worse.
"Just Learn AI" Is Not a Complete Answer
I also think a lot of advice in this space is too glib.
Yes, new developers should learn the tools.
Yes, refusing to use AI is stupid.
But "use AI" is not a career plan by itself.
If all you do is use AI to go faster at the exact layer the market is already trying to devalue, you are not escaping the problem. You are sitting inside it.
The safer value is moving upward:
- clearer requirement breakdown
- systems thinking
- architecture judgment
- debugging generated nonsense
- knowing when code only looks correct
- understanding how product and business logic actually fit together
That is a different bar from "can write code."
The Long-Term Risk Is a Pipeline Collapse
This is the part I think companies are sleepwalking into.
Senior engineers do not appear from nowhere. They usually come out of years of doing smaller, messier, repetitive work until the pattern library in their head gets strong enough to handle harder things.
If companies gut that layer too aggressively because the short-term savings look amazing, they may discover later that they saved money by burning down the path that used to produce their future seniors.
That kind of mistake is very believable to me.
It would fit the pattern perfectly:
- celebrate efficiency now
- ignore the training problem
- panic later when the market is full of people who have used AI tools but have never actually built deep judgment
What I Would Tell a New Developer Right Now
If I were starting today, I would stop thinking of the goal as "be someone who writes code."
That is too small.
I would aim to become someone who can:
- understand the whole system
- spot where generated code is weak
- trace bugs across layers
- reason about permissions and failure states
- turn vague requests into workable architecture
- use AI without trusting it blindly
Because the market is going to pay less for raw code output than it used to. It is going to pay more for the person who knows whether that output is safe, complete, and worth shipping.
Final Thought
So no, I do not think AI simply "kills programmers."
I think it does something nastier first.
It hollows out the cheap, repetitive, beginner-friendly work that used to teach people how to become programmers in the first place.
That is why the real fight here is not AI versus software engineering.
It is AI versus the junior ladder.
And if that ladder collapses, the damage will not show up only in this year's hiring numbers. It will show up a few years later, when everyone suddenly realizes how hard it is to find people with real judgment.