AI-Generated Legacy

Every business has at least one thing that works and nobody can quite explain. The spreadsheet only one person knows how to update. The workaround that’s “just how we do it.” The tool some vendor set up years ago that everyone’s a little afraid to touch. It runs, so nobody asks how. That’s fine, right up until the person who understood it leaves, or it breaks on a Tuesday, and you’re standing in front of something your business depends on that nobody in the building can actually fix.

That problem is as old as business. What’s new is the speed.

The old version took decades to form. A system got built, the people who understood it moved on, and the knowledge quietly left with them. That’s what legacy really is: not old code, but lost understanding. The new version can form in months. You ask a machine for something and it hands you a finished version almost immediately: a document, a process, a tool, a piece of software. It runs. It passes the obvious checks. It goes into use. But does anyone actually understand it? Why it was built this way, what it quietly depends on, what breaks when the inputs change, which parts are holding the whole thing up and which are just along for the ride.

When a person builds something, there’s usually reasoning underneath it, a chain of decisions, good or bad. When a machine produces it, that link gets thin. The result may be perfectly correct. But it was assembled by something that never understood your business, your history, or the ten-year-old decision nobody remembers but everybody still lives with. It produced something that looked right, which is genuinely useful, and it’s also how you end up trying to fix a thing that never had a reason behind it in the first place.

The bottleneck was never producing the work. It was understanding it. What are we building, and why? What does it touch? What happens when it fails? Who can explain it? Machines make the producing part almost free, which strips out the friction that used to force people to slow down and think. Building something used to take long enough that some of the reasoning stuck. Now you can have a finished result before you understand the shape of the problem. Sometimes that’s real acceleration. Sometimes it’s just debt in nicer packaging.

There’s a serious counterpoint here, and it’s worth taking seriously: maybe people don’t need to understand the details, because the machine becomes the expert. You stop being the builder and become the person directing the intelligence that builds. That can work. But only if you still understand the right things: what you’re trying to accomplish, what can go wrong, and how you’d know whether the result is any good. Understand that, and the machine is a powerful specialist working under you. Understand none of it, and you’re not directing anything. You’re hoping. Directing is not the same as handing over the keys.

I know the shape of this because I’ve lived it. A system I built to be disciplined, with the guardrails set and the documentation done right, still grew past the point where I could hold all of it in my head. In practice, the AI is the expert on it now. The only reason it never held me hostage is that everything got written down as we went: every decision, every dead end, every fix, in plain language, kept with the work and dated. The understanding lives on disk, not in a model and not in me. We can’t always say exactly where in the code something happens, but we can reconstruct why it’s there, and rebuild it from principle. That’s the whole difference between a system that outgrew its owner and one that quietly got away from him.

So the real question isn’t whether you understand every detail. It’s whether you understand enough to tell whether the thing now running your operation is right. The people who can answer that are going to matter more, not less. The world won’t be short on output. It’ll be short on people who understand what all that output is doing, and whether it can be trusted.

That’s the real risk. Not that the machines get too smart, but that we build things nobody understands, using tools that make it easy to move faster than our own comprehension. It’s the oldest problem in business, something important that nobody left can explain, except now it arrives faster than we’ve ever seen. We used to get decades before we found out what we’d built. Now we might find out next quarter.