I deleted 3 months of AI-generated code. Here is what I learned.

A post appeared on Reddit last week that hit harder than most think-pieces about AI and the future of programming. The title: "I mass deleted 3 months of AI generated code last week. Here is what I learned."

The developer - building a side project using ChatGPT, Claude, and GitHub Copilot - described shipping fast, feeling productive, and watching the codebase grow. Then they needed to add a feature that touched most of the code. And discovered they couldn't do it. Not because the feature was technically hard. Because they didn't understand what the code did.

Three months of work, deleted.

Why This Happens

There's a specific failure mode that emerges when you use AI coding tools in accept-everything mode. The code works. It passes your tests. It ships. But you didn't write it, you didn't struggle with it, and - crucially - you didn't build a mental model of it.

Traditional programming forces you to understand the code you write because you're building it piece by piece. When something breaks you debug it, which means you go deeper into how it works. When you refactor you're actively restructuring your understanding of the system. That slow, sometimes frustrating process is also how you internalize a codebase.

AI skips all of that. You describe what you want, get working code, accept it, move on. Fast. Productive. Until the day you need to understand the system you built.

This Isn't an Argument Against AI Coding Tools

The developer who deleted their code made a thoughtful point in their post: they're rebuilding the same project now, using AI again. But differently.

The change: they read every line before accepting it. When the AI does something they don't understand, they ask it to explain. When they hit a bug, they try to understand it before asking AI to fix it. It takes longer. But they understand what they're building.

This is the actual skill of using AI coding tools well, and it's underrated in the discourse about how transformative these tools are. Cursor can edit six files simultaneously and get it right. That's remarkable. But if you don't understand what changed across those six files, you've borrowed productivity from a future version of yourself who will have to fix something they can't understand.

The Developers Getting This Right

The pattern we've observed in developers using AI tools effectively is consistent. They use AI heavily for boilerplate, tests, and the mechanical parts of code. They stay engaged on the architectural decisions, the tricky logic, anything that requires genuine understanding of the system.

One way to think about it: use AI to move faster on the parts you already understand, and slower (or not at all) on the parts you don't. If the AI is doing something you couldn't have written yourself and can't explain, that's a signal to slow down, not a reason to ship faster.

The most useful framing we've come across: treat AI-generated code like code from a contractor. You wouldn't merge a contractor's code without reviewing it and understanding it. The same principle applies.

What This Means for Learning to Code

For people learning to program, this is a harder conversation. AI tools can generate working code so quickly that it's tempting to skip the parts that feel slow: understanding error messages, debugging line by line, rewriting things that don't work. Those parts are frustrating. They're also where most of the learning happens.

We're not going to tell you not to use AI while learning. That ship has sailed. But if you're using Cursor or Claude to learn, try this: before accepting any AI suggestion, make sure you can explain what it does. If you can't, ask the AI to explain it. Then ask yourself if you would have written it the same way, and why.

Slower. More annoying. Actually understanding what you're building.

The developer who deleted three months of work is rebuilding faster the second time, because now they understand what they're doing. That's not a story about AI failing. It's a story about what you need to bring to the table when you use it.