Technical Debt

Every shortcut you take to ship today is a loan. And like every loan, it charges interest.

I felt this one in my body before I had a word for it. Early on, building fast with AI, I'd tell it "just make it work, I don't care how." And it would. The thing shipped. I felt like a genius. Then two weeks later I'd go to change one small thing and the whole house of cards wobbled. A five-minute tweak somehow ate an afternoon. I hadn't broken anything new. I was just finally paying for the corner I cut back when I was feeling like a genius.

That gap between "this was so fast" and "why is everything so hard now" is technical debt.

Here's the loan, made concrete. You need a feature out the door tonight. There's a clean way to build it (takes a day) and a hacky way (takes an hour). You take the hour. Smart move, honestly. You hit the deadline. But you didn't actually save the work, you borrowed it from future-you. And future-you pays it back with interest every single time they touch that part of the code.

The interest shows up as friction:

• The "quick" fix that mysteriously takes a week.
• One change that breaks three things you swore were unrelated.
• A new hire (or a fresh AI session) taking forever just to understand how anything fits together.
• That one file everyone on the team is quietly scared to open.

None of that is a bug. It's the bill arriving.

The part that matters: debt is not a sin. This is where people get it twisted. A little debt is normal, and often it's the right call. You borrow speed to hit a launch, win the customer, prove the idea is even worth building well. Founders do this on purpose constantly. Cutting a corner to ship is not the mistake.

The mistake is never paying it back. Debt you ignore doesn't sit still. It compounds. Cut enough corners and never circle back, and one day you've got a codebase where every change is slow, every fix is scary, and the whole thing grinds to a crawl. The team isn't lazy. They're just servicing interest on a hundred old shortcuts, with nothing left over to build anything new.

Why this hits harder the second AI is in the mix. When you're vibe coding, you can generate an enormous amount of "it works" in an afternoon. That feels amazing. It's also the fastest way to rack up debt you can't even see, because you didn't write the code and have no idea which corners got cut. The AI optimized for "make it run," exactly like you asked.

So a few habits that keep the bill manageable:

1. Borrow on purpose, out loud. When you take the hacky route, say so. Drop a note in the code, an issue, a doc: "this is a shortcut, here's the real fix later." Debt you wrote down is debt you can pay. Debt you forgot is the kind that ambushes you.

2. Pay a little, often. You don't need a giant "clean everything up" project (those never happen anyway). Tidy one rough edge each time you're already in that part of the code. Small payments beat the balloon payment that never comes.

3. Ask the AI to find the bill. Point it at a messy area and ask plainly: "What shortcuts are in here, and what's going to bite me later?" It's genuinely good at this. You can't pay down debt you can't see, and it'll surface the corners you forgot you cut.

The fast version and the right version are rarely the same version. That's fine. Just remember which one you picked, and that the bill is coming either way.