These days, things move so fast it's almost intoxicating. You enter a prompt, watch the lines of code fly across your screen, and within ten minutes, you have a feature that used to take three days. It feels like flying.
But anyone who has ever been near a volcano knows this: liquid lava flows at lightning speed and looks impressive, but as soon as it cools, it turns into solid rock.
In software engineering, we call this the Lava Layer. And right now, we’re pouring this layer onto our codebases at a record pace. The layer has a twin that never hardens, by the way: code churn, the lava you can still measure.
The Illusion of Ownership
When you write an algorithm yourself, you build a mental map. You know why that if statement is there, why you chose that specific array method, and which edge cases you’ve accounted for (consciously or unconsciously). That’s not abstract knowledge; it’s the intuition you need when something breaks at 3 AM.
With AI-generated code, that map is missing. You aren’t an architect; you’re a curator. You look at the code, see that it "works" (after all, the tests are green, right?), and you click merge.
At that moment, the first crust of the lava layer forms. You’ve added code that is technically functional, but whose "soul" no one on the team truly understands.
The Refactoring Trap
The real problem only surfaces six months later. Business requirements change (as they always do), and that complex module the AI spat out needs to be overhauled.
In a healthy codebase, that’s a matter of surgical intervention. But with a lava layer, no one dares to touch it. Because the original logic didn’t emerge from a human thought process, but from a statistical probability, the connections are often fragile and illogical to our brains.
The result?
- Fear-driven development: "Don't touch that module, because we don't know what might break."
- Hacks-on-hacks: Instead of improving the code, you build around it. The lava layer gets thicker and thicker.
- Loss of velocity: The initial gain you achieved with the AI agent is now being paid back with interest because every change takes three times as long.
On top of that, the agent itself performs worse and worse in such a frozen codebase: your agent's suffering is your tech debt speaking.
How Do You Recognise the Lava Layer?
You can measure the petrification of your project quite simply. Ask yourself and your team the following questions:
| Symptom | Cause | Danger Level |
|---|---|---|
| "The AI understands it better than I do" | You’ve lost control over the logic. | 🔴 Critical |
| "I don't dare to adjust this unit test" | The test is an echo chamber for the AI's mistake. | 🟠 High |
| "Let's just throw this file away and prompt it again" | You’re gambling, not building. | 🔴 Critical |
Bust Out the Jackhammer
Does this mean we should go back to the typewriter? Of course not. But we need to stop pouring liquid lava.
- Limit the scope: Let the AI write small, manageable functions. No complete classes or complex orchestration layers. Make it search before it writes, too, or you end up with twenty near-identical helpers for one job.
- The 15-minute rule: If you can’t fully explain the code the AI generates to a junior developer within 15 minutes, it doesn’t go into the repo.
- Review like a skeptic: Don’t treat AI code as a suggestion from a brilliant colleague, but as a pull request from an enthusiastic intern who's had way too much caffeine.
- Schedule the jackhammer: the layer that has already hardened only comes out in a deliberate cleanup pass, planned like backups, not saved for a quiet week.
Speed is wonderful, but maintainability is what keeps your business upright. A codebase consisting entirely of AI lava is a sprint champion in the short term, but a statue in the long term: beautiful to look at, but completely immobile.
Stay in control. Remain the owner. And don't let the lava harden.