LUMP Depot
There's a pattern I keep seeing. The AI vendors are selling speed, selling savings, selling the dream of ten-engineers-for-the-price-of-one. And they're doing it before anybody has figured out the safety part.
It's like selling a car with no airbags and telling the buyer, "don't worry, we'll figure that out once you're on the highway."
Dario Amodei said the other day that "coding is going away first, then all of software engineering." Grady Booch called it out as IPO pump. Gergely Orosz said the only people who believe it are non-coders. They're all right. But the hype train doesn't stop because a few people are standing on the platform waving red flags.
Ten times zero is still zero
Here's the thing nobody selling you an AI coding subscription wants to admit: these tools multiply what you already have. If you're a solid developer, you can genuinely 10x your output. I've seen it. It's real.
But 10x a person with zero coding skills is still zero. Worse, actually, because now they think they shipped something. They didn't ship software. They shipped a liability with a login page.
The pitch is always "anyone can code now." As Gino D'Acampo once said, if my grandmother had wheels she would have been a bike. Giving someone an AI agent doesn't make them a software engineer. It makes them a person with an AI agent.
The new drudgery
So what does the job look like now for the people who actually know what they're doing? Code review. Endless, grinding code review.
Here's the irony. Writing high-quality code to spec, once the plans are in place, is satisfying work. It's the part most developers got into the profession to do. Now the agent handles that part (sort of), and the developer's real job has become reviewing whatever the agent produced and hoping it didn't hallucinate a dependency or silently break an integration.
Code review takes longer than writing good code. When you wrote it yourself, you understood every line because you thought through the problem. When you're reviewing someone else's output, you have to reverse-engineer the intent. Now multiply that by an agent that generates code faster than any human, with no understanding of why it made the choices it made.
We're short-circuiting the process. Idea straight to code, skip the architecture, skip the design doc, skip the part where you think about whether this thing is maintainable in six months. Ship it. Tokens consumed. Invoice sent.
The meter is running
I can just picture the token gas-station reels spinning. Every revision, every failed review that sends the agent back for another pass, every "try that again but differently" is another burst of tokens billed to your account.
The business model is beautiful if you're selling tokens. The worse the initial output, the more iterations the customer needs, the more you bill. There's no incentive to get it right the first time. There's incentive to get it close enough that you keep trying.
AI service providers have to be rubbing their hands together. You're paying to generate slop, then paying again to fix the slop, then paying a third time when the fix introduces a new bug. The meter never stops.
Who trains the next generation?
Here's where it gets dark. The senior developers who actually know how to architect systems, review code, and catch the things agents miss? They're burning out. The job went from building things to babysitting a machine that builds things badly and confidently.
Once you burn them out, who trains the juniors? And there aren't many juniors coming up anyway, because the entry-level jobs are evaporating. I wrote about this before: the junior-to-senior pipeline is the engine of the whole profession. Break it and you don't just lose a generation of developers. You lose the institutional knowledge that makes software reliable.
A few years from now, when the vibe-coded systems start crumbling at scale, who picks up the pieces? The agents? The same ones that created the mess?
The barrel is right there
Business leaders should be able to see this. The barrel is sitting right in front of them, and the vendor is asking them to bend over it. "Don't worry about senior devs, you don't need as many. Don't worry about code quality, the AI handles that. Don't worry about testing, it writes its own tests."
Then production goes down on a Tuesday and nobody on the team understands the codebase because nobody wrote it.
The question is whether they stop before it's too late. History says they won't. The business people need to crash the car before anyone will listen to the engineers saying "maybe we should install airbags first."
I'm not holding my breath. But I'm keeping my seatbelt on.