The tech debt you can talk away

One of the developers I spoke with recently had been sitting inside the same codebase for several years. The kind of system nobody dares touch. It works, it invoices, and the documentation is either outdated or non-existent. Everyone at the company treats it like a black box with a note on it: do not touch.

I asked him to do something that felt wrong to him. Start a recording and just talk. Not write. Not document. Tell me, out loud, what the code does. Where it gets complicated. What he always checks before changing anything. Which assumption is buried in a function that nobody remembers why it looks the way it does.

It's unfamiliar for a developer to talk about their code. We're used to writing it, not narrating it. But after a minute or so, it loosened up.

What Actually Happens

That recording is not a dictation exercise. It's raw material.

You take the transcript and run it against the codebase. And that's where things get interesting. The AI finds the diffs -- the gaps between what he said the code does and what it actually does. It finds the documentation holes, because now there's finally a description to compare the code against. It finds the assumptions he mentioned in passing, the ones that were never written down anywhere but that the entire system rests on.

You haven't rewritten a single line. You haven't built anything new. But you've just moved a significant portion of the tech debt from nobody-knows to someone-knows. My experience is that you can push away roughly a fifth of it just by applying AI to the old processes, not only to the new build.

Why It Works

Knowledge about an old system rarely lives in the repo. It lives in the head of whoever has lived with it. The three-in-the-morning debugging sessions, the times it broke, the unspoken rules about what you never do. None of that is checked in anywhere.

A language model can only work with what's in the context window. And the one thing a legacy codebase lacks is exactly what the developer carries around. Voice is the only practical way to get it out. Ten minutes of speech holds more of the real mental model of a system than anyone can write down in a week.

And one more thing -- which is the entire point. The developer remains the one who owns what is true. The AI structures what he said and points to where it scrapes against the code. But it's him who decides what actually holds. This is not an automation that replaces his judgment. It's one that amplifies it.

This Is Not a New Tool

This is the most boring use case I know. No generated video, no agent doing twenty things at once. A developer talking about old code. It's unglamorous and unimpressive, and that's probably why nobody talks about it.

It's not new either. This was possible with transcription several years ago. The technology has never been the obstacle. The obstacle has been someone thinking to turn the voice pipeline backwards -- toward the old stuff instead of the new.

The Position Is Open

Everyone is building forward with AI. Greenfield, new features, fast prototypes. Few turn the tool backwards, toward the systems that actually carry the business and that nobody dares document.

That's where the biggest debt is. And it's the debt you can talk away.

See also: Everything I Say Ends Up as Text (series 2) and Messy and crisp (series 14).

Mindtastic on greenfield versus legacy in production -- Production Reality Gap.