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.
They're arguing about typing.
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.
Mistake 2: Treating the skill ladder as a fixed object
This is the one that actually matters, and nobody prices it in.
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.
Mistake 3: Benchmarking on the demo instead of on 2am
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.
The synthesis: stop predicting, start structuring
Here's what I actually believe after 30 days of building and 500 posts of reading.
"Will AI replace developers?" is an unanswerable, and frankly boring, question. It's astrology for engineers. The useful question is structural, and it's answerable today:
What has to be true for AI's output to be trustworthy?
My 30 days gave me the answer, and it has nothing to do with which model wins. The thing that writes the code can never be the thing that reviews it — a model grades its own homework and always passes. You need a separate reviewer whose entire job is to refute the diff, not bless it. You need a human on the merge button who can see the blast radius the model can't. Author here, skeptic there, human owning the decision.
That's not a prediction. It's a structure. And it's the same structure whether the model is GPT-9 or something we haven't built yet, because it doesn't depend on the model being good — it depends on the model being checked.
It's also, not coincidentally, exactly how we build xenition: an agent that does the work, a different agent that tries to tear it down, and a person who owns the merge. I didn't arrive at that from a thesis. I arrived at it from 9 logged breaks on a real build, every one of which was the model waving through its own mistake.
The doomers and the hypers are both waiting to find out who wins. The people shipping are busy building the structure that makes it not matter.
So, honest question for the comments: which of the three mistakes have you caught yourself making? I made all three before the experiment beat them out of me — the demo one twice. 👇
(If this reframed the argument for you even a little, a ❤️ and a 🔖 help more than you'd think.)
