Last month I spent 30 days letting AI write 100% of my code — a real SaaS, in production, no line of app code typed by me. Then I did the thing you're supposed to do after an experiment: I went and read what everyone else thinks is happening.
So I read the discourse. Not a few hot takes — I went deep, hundreds of posts, threads, and "the end of programming" essays, from both camps. The breathless "developers are obsolete by Christmas" crowd and the smug "AI is a stochastic parrot that can't count the r's in strawberry" crowd.
Here's the strange part. They agree on almost nothing — except they all make the same three mistakes. And once you see the three, you can't unsee them, because every prediction in your feed is built on at least one.
This isn't a hype post and it isn't a doom post. It's a post about why almost every hype post and every doom post is wrong for the exact same reasons.
Mistake 1: Arguing about "can AI write code?" when that was never the bottleneck
Every post, on both sides, is secretly an argument about code generation. The optimists show a model one-shotting a working app. The pessimists show a model hallucinating an API that doesn't exist. Both think they're arguing about the future of the profession.
Here's what 30 days of AI writing everything taught me: the typing was never the hard part. It just felt like it was. The AI wrote my CRUD, my Zod schemas, my scaffolding — flawlessly, faster than I ever could. And it changed my output by maybe 20%, because writing the code was 20% of the job. The other 80% was knowing which code, knowing when it was subtly wrong, and knowing what not to build at all.
So when someone benchmarks a model on "can it produce a working function," they're measuring the one part of engineering that was already the least of our problems. It's like judging a surgeon on how fast they can make an incision. Speed at the easy part tells you almost nothing about the hard part.
The whole "will AI replace developers" debate is conducted in the units of the thing that mattered least.
The optimist's argument: "Juniors + AI will be as productive as seniors, so we'll need fewer seniors and everyone levels up." The pessimist's argument: "AI does junior work, so junior jobs vanish and it's a bloodbath." Both of them are standing on the same hidden assumption — that the ladder from junior to senior stays where it is while AI rearranges who stands on which rung.
But the ladder is made of the work. You become a senior by doing ten thousand hours of exactly the work AI is now absorbing: the scaffolding, the boilerplate, the confident-but-wrong first draft you learn to distrust by being burned. That's not busywork you graduate past. That's the curriculum.
AI didn't replace me in my experiment. It replaced the tasks I used to hand to juniors — which means it didn't flatten the hierarchy, it sawed off the bottom rungs while making the top rungs more valuable. The static-ladder crowd is arguing about who gets to climb. The real question is who's going to build the rungs now that the thing that used to build them for free is gone.
You can't skip the 10,000 hours. You can only move where they're spent. And right now the industry is quietly deleting the place they used to be spent and assuming the seniors will keep appearing anyway, the way electricity keeps coming out of the wall.
Every prediction — hype and doom alike — extrapolates from a demo. The optimist's demo: watch it build a todo app in 90 seconds. The pessimist's demo: watch it fail a riddle. Both are the happy path. Both are the moment of the screenshot.
Production is not the screenshot. Production is 2am, a real user doing something weird, a database blip, a double-clicked button, an empty state nobody designed.
In my 30 days the scariest thing the AI wrote wasn't code that crashed — it was code that ran. A Stripe webhook that acknowledged events before persisting them. Flawless in every test. In production, one DB blip = a paying customer with no access and no record they ever paid. It passed its own tests, because the model wrote tests that agreed with its own wrong mental model. "It compiles and the tests are green" is where the demo ends and where the real work begins.
So when a post predicts the future by pointing at a demo, it's making a claim about the 10% that's easy and staying silent about the 90% that's hard. "It ran" is not "it worked." Every extrapolation from a demo to a profession quietly swaps one for the other, and hopes you won't notice.
Here's what I actually believe after 30 days of building and 500 posts of reading.