I started programming at 12, writing RATs and trojans in Delphi because that’s what Romanian kids did in 2002. By 21 I was a literature graduate building CRMs from scratch in PHP. No computer science degree, no bootcamp, no mentor. Just a shit internet connection, Notepad++, and an obsession that wouldn’t let me sleep.
I learned to scrape websites by building leech sites — parasitic clones that leeched databases from other sites and ran on $1 VPS instances or free hosting providers. That meant manually inspecting HTML, writing regex patterns that made my eyes bleed, handling encoding issues, dealing with rate limiting, figuring out session cookies. I already knew networking from writing trojans as a kid — ports, sockets, connections, all the shit you learn when you’re trying to get a reverse shell to phone home through a firewall. I learned concurrency because my scraper was too slow and I had to figure out how to run multiple things at once without corrupting shared state.
Every single one of those lessons came from pain. Hours of debugging. Days of being stuck on something that turned out to be a missing semicolon or a wrong port number. The pain was the curriculum. The struggle was the teacher.
Now a junior developer hits the same wall, pastes the error into Claude or ChatGPT, gets the fix in 10 seconds, and moves on. Zero learning happened. The pain was skipped. And the pain WAS the education.
The Calculator Problem
It’s like giving someone a calculator before they understand multiplication. Yeah they get the right answer, but they have zero intuition for when the answer is wrong. You ask them “does 7 times 8 equal 312” and they just shrug because they never built the gut feeling that should make them go “that doesn’t look right.”
AI tools work the same way. A new developer prompts Claude, gets working code, ships it, feels like a genius. But the moment something breaks in a way the AI can’t fix — and that moment ALWAYS comes — they’re completely helpless. No mental model of what’s actually happening. No ability to reason about the code they’re running. No intuition for where to even start looking.
When my scraper breaks, I know exactly where to look because I understand every layer — the HTTP request, the response parsing, the encoding, the session management, the rate limiting. I built that understanding by spending hundreds of hours doing it wrong first.
A new developer’s scraper breaks and they paste the error back into ChatGPT and pray. Works 80% of the time. The other 20% they’re completely fucked.
The Gym With a Robot
It’s like going to the gym but having a robot lift the weights for you. Yeah the weight moved, but your muscles didn’t grow. You look the same walking out as you did walking in.
The developers who learned before AI had to lift every weight themselves. Every bug fixed manually. Every architecture decision made through trial and error. Every deployment script written by hand after the third time you fucked up a manual deploy. That’s how you build engineering muscle.
Now there’s a generation of developers who’ve never written a for loop from scratch without AI assistance. Never debugged a regex by hand. Never sat there for four hours figuring out why their code is off by one. Never had to THINK about what a function actually does because they can just ask the machine to explain it.
They can produce code. They can ship features. They can pass code reviews because the AI-generated code looks fine. But they can’t debug. They can’t architect. They can’t reason about systems. Because they skipped the part where you learn those things — which is the part where everything is broken and you have to figure out why.
The Interview Problem
Companies can’t tell the difference anymore. Two candidates walk into an interview. Both can “build a scraper.” Both can “set up a REST API.” Both can “write unit tests.” One actually understands what they’re building. The other is a proxy for an LLM.
Good luck figuring out which is which in a 45-minute technical screen where the candidate has Copilot running in their IDE.
And the irony is thick — the entire FAANG interview system was already broken before AI. Making developers whiteboard red-black trees and quicksort for jobs where the biggest table has 2000 rows and the heaviest endpoint gets called twice a day. Some guy is out there studying Leetcode for 6 months to get a job where the actual work is wiring APIs together and figuring out why the staging environment is broken on Tuesdays.
Now add AI to that mess. The whiteboard questions are useless because candidates can practice with AI until they memorize every pattern. The take-home projects are useless because AI can generate a complete solution in minutes. The pair programming sessions are useless because the candidate is just translating between the interviewer and their mental model of what to ask Claude.
The only thing that still works is sitting with someone and watching them debug a real problem in real time without tools. And almost nobody does that because it takes too long and doesn’t scale.
The Hollowed-Out Middle
Here’s where it gets really dark. The path from junior to senior developer has always been: struggle for years, build deep understanding through pain, eventually develop the intuition and systems thinking that makes you senior. That path required the struggle. Remove the struggle, and the path disappears.
So what happens in 10 years? A tiny elite of senior engineers who learned before AI and actually understand the fundamentals. A massive pool of juniors who are essentially AI operators — productive when the tools work, helpless when they don’t. And nothing in between, because nobody’s making the journey from one to the other anymore.
The learning ladder is getting pulled up. Not maliciously — nobody planned this. But the effect is the same. The tool that makes you productive today is the same tool that prevents you from becoming truly competent tomorrow.
And you can’t tell a 20-year-old “don’t use AI, struggle manually for 5 years first.” That’s like telling someone in 2005 “don’t use Google, go to the library.” They won’t. Why would they? The rational choice for any individual is to use the most powerful tools available. The problem is that what’s rational for the individual is catastrophic for the profession.
What Still Matters
The developers who will survive this aren’t the ones who can write the most code. AI already does that better than most humans. The survivors are the ones who understand WHY things work.
Understanding WHY is what lets you:
- Debug problems that AI can’t solve because it’s never seen that specific combination of failures
- Architect systems that don’t fall apart when requirements change
- Evaluate AI-generated code and catch the subtle bugs that look correct but aren’t
- Make decisions that require understanding trade-offs between approaches, not just picking the first one that compiles
- Know when the AI’s suggestion is wrong because your gut says “that number doesn’t look right”
That intuition only comes from doing it the hard way first. There’s no shortcut. No AI can give it to you. It’s earned through years of sitting in the shit and figuring things out.
The Self-Taught Advantage
Here’s the twist nobody expected: self-taught developers might actually have the biggest advantage in the AI era. Not despite learning the hard way, but because of it.
We didn’t have curricula. Nobody handed us a learning path. We grabbed problems by the throat and figured shit out because we wanted to, not because a syllabus told us to. That habit — of being genuinely curious, of wanting to understand how things actually work, of not being satisfied until you’ve traced the problem to its root — that habit is exactly what survives the AI disruption.
The CS graduate who memorized data structures for exams never developed that habit. They learned WHAT to do, not HOW to think. When their memorized patterns don’t match the problem, they’re stuck. When the self-taught developer’s patterns don’t match, they dig deeper because that’s all they’ve ever done.
Interest is the only sustainable competitive advantage in tech. Everything else can be learned, copied, or automated. But you can’t automate giving a shit.
The Uncomfortable Truth
90% of production systems will never need the kind of deep knowledge I’m talking about. Most business apps could run on bubblesort, no database indexes, SELECT * from every table, and nobody would notice because the biggest table has 847 rows and the database doesn’t even break a sweat.
For those systems, AI-assisted developers are fine. More than fine — they’re faster and cheaper. The code works, the features ship, the business doesn’t care how the sausage gets made.
The problem is the other 10%. The systems that actually matter. Financial platforms processing real money. Infrastructure that people depend on. Security systems that can’t have subtle bugs. The systems where “it works 80% of the time” isn’t good enough and the 20% failure case costs millions.
Those systems need engineers who understand the fundamentals. And we’re about to have a severe shortage of them, because the pipeline that creates them just got replaced by a shortcut that produces something that looks identical on the surface but crumbles under pressure.
The senior engineers who exist today were forged in the fire of manual debugging, hand-written code, and years of painful learning. When we age out, who replaces us? The developer who’s been copy-pasting AI output for a decade? That’s not a senior engineer. That’s a very experienced prompt writer.
And the industry doesn’t seem to care. Because right now, today, the AI-assisted developer ships features faster. The ROI looks great on the quarterly report. The technical debt is invisible until it isn’t. And by then it’ll be someone else’s problem.
Same as it ever was. Just faster now.