I've been thinking about something that keeps coming up in the spaces I read.
Builders shipping fast. AI tools cutting the time to first working version from weeks down to days. Projects that would have taken a month of evenings getting demo-ready in a weekend.
And then, a few months later, those same projects becoming unmaintainable.
There's a specific failure mode going around right now. I don't think it's talked about enough, because the people experiencing it are in the middle of it and not quite sure what to say. It's not a crash that happens all at once. It's a slow grind where every new feature takes longer than the last, where debugging feels like archaeology, and where at some point you realize you don't actually understand the thing you built.
What Vibe Coding Actually Is
The term comes from Andrej Karpathy, early 2025. He described a way of building where you tell the AI what you want, accept what it gives you, and ship it if it seems to work.
Prompt. Generate. Glance. Commit.
It's not inherently reckless. For prototypes and experiments, it's genuinely useful. I've done it. Most people building with AI tools have done some version of it.
The problem is when that approach becomes the whole workflow.
Because the code it generates is often not quite right in ways that aren't immediately visible. The logic works in the happy path. It doesn't handle edge cases well. It copies patterns from its training data that are almost correct — and sometimes those patterns carry subtle vulnerabilities or structural issues that don't surface until real usage.
One indie developer built an entire SaaS product with Cursor. Zero hand-written code. It worked. He shipped it. And then within weeks he was dealing with "random things happening," his AI assistant kept breaking other parts of the app when trying to fix things, and he couldn't debug it because he didn't write it and didn't fully understand it.
That's the 90-day wall.
The Part That Makes It Sneaky
What makes this hard is that the feedback loop is completely inverted from what you'd expect.
Early on, everything signals success. You're shipping fast. Features are getting done. The product looks real. You feel more productive than you've ever felt.
The data on this is kind of wild: 74% of developers using AI coding tools report feeling more productive. But research is simultaneously showing 45% of AI-generated code contains security vulnerabilities, and code duplication is up 48%. The subjective experience and the objective measurement are going in completely different directions.
You feel productive. The codebase is quietly accumulating a debt you haven't noticed yet.
And then somewhere around month two or three, the velocity you gained starts getting paid back with interest. Simple features take longer because you can't trust the codebase. Refactoring becomes a prerequisite for anything new. The thing that was supposed to give you more time starts eating it.
The cycle typically completes in six to twelve months. By the end, the cost of unwinding it often exceeds the value of what was built.
The Other Half: Agentic Fatigue
There's a second thing happening alongside this that I find even harder to talk about.
It's the version where you're not just using AI to write code — you're running agents. Actual agentic workflows. Automated pipelines. Things that execute in the background while you're doing other things.
And it starts feeling like more leverage than you've ever had. Because it is, at first.
But there's a real burnout pattern emerging. Builders in their early 20s working until three in the morning because the build is almost done and the agent is still running and it feels like stopping would waste momentum. The agent does the work, but you're still context-switching between its output and your own judgment, reviewing code you didn't write, catching mistakes before they ship.
I'm not completely sure where I land on this yet. I think there's a real version of agentic workflows that adds genuine breathing room. And there's a version that just replaces one kind of exhaustion with another.
The difference, from what I can tell, is whether you're building systems you understand — or just automating the generation of things you don't.
What I Keep Coming Back To
I've been thinking about this in terms of two different relationships you can have with the tools.
One is: the AI writes the code, you ship it, you move fast, and you defer the understanding until later. Later usually doesn't come.
The other is: the AI handles the parts that are genuinely repetitive or structurally predictable, and you stay close to the parts that require judgment. You actually read what gets generated. You make decisions about structure. You know what the thing is doing and why.
The second approach is slower. But it compounds differently.
I think what I'm slowly realizing is that the velocity wins from AI coding are real, but they're not free. They shift cost rather than eliminate it. If you borrow from future understanding, you'll pay it back eventually.
The builders I see getting real mileage from these tools aren't the ones moving fastest. They're the ones who figured out where to slow down.
What This Actually Looks Like in Practice
I'm still working this out for my own projects. But a few things I keep noticing:
If I use an AI tool to generate something and I can't explain what it's doing in plain terms, that's a signal. Not that the code is necessarily wrong, but that I haven't done the work of actually understanding it yet.
The tools that help me think are different from the tools that help me produce. Both matter. They don't always overlap.
Speed is real leverage. But speed on top of confusion just gets you to the confusion faster.
I'm not sure this is some massive revelation. Most experienced developers probably already know this. But I think for a lot of people early in their building journey right now, the tooling is so good and so fast that the feedback loop is broken. It takes months to see the consequence of how you built something.
And by then, the thing you built is supposed to be a business.
I don't want to sound like I'm warning against AI tools. I use them every day. I'm building with them right now.
I just think the honest version of the story includes the wall.