So lets talk about money a little bit, ok? For like a decade, interest rates were basically zero. They called it ZIRP (Zero Interest Rate Policy) and suddenly everyone was borrowing like mad. Paying off debt wasn’t happening any faster. Carrying it just cost nothing.
Companies leveraged themselves to the moon. Why not? It was basically unlimited free money.
And now it's happening to code.
I knew this tortoise once who carried a perfectly reasonable shell. Hexagonal plates, decent weatherproofing, traditional design passed down through generations. Then ZIRP hit.
"Why have one shell layer," the tortoise mused, "when I could have thirty?"
So the tortoise borrowed. And built. And borrowed. And built. The shell became a fortress. Layers upon layers upon layers. Some had purposes. Some didn't. Some the tortoise forgot about entirely.
"Aren't you worried?" his friend the anxious hare asked.
"About what? It costs nothing to carry them."
People keep saying slop like it’s a bad thing.
Like we’re drowning in AI-generated garbage.
But have you ever watched a master chef at work? There’s flour on their sleeve, six pans going at once, half-prepped herbs scattered like confetti. They taste, adjust the acid, whisk a sauce, pull something from the oven early, toss in one last dash of salt, all in seconds.
To the untrained eye, it’s a mess. To them, it’s a practiced rhythm.
It looks like chaos. It looks like… slop.
I’ve tasted the slop. It’s delicious.
But look, I’m not saying that ZIRP made debt go away. I’m saying that it makes debt irrelevant.
Last weekend, Orta Therox posted "6 Weeks of Claude Code" and dropped this insight:
If you understand what you are doing, the capacity for building and handling the breadth of tasks which typically live within the remit of 'technical debt' do not need to be treated as debt and you can just do it as you are working on other things.
And something clicked for me. AI isn’t creating a technical debt crisis. We're in technical debt's ZIRP era!
When carrying costs approach zero, the rational strategy isn't to borrow less, it's to borrow MORE. Way more. Absurd amounts more.
Same with code now.
Why? Because the cost of carrying bad code has collapsed. Because now we can carry INFINITE amounts of it.
Here's the thing that would have horrified us five years ago: our standards should be getting LOWER, not higher.
Fear used to run the place. Fear of breaking the build, of untangling a stranger’s 4-year-old regex, of that ticket labeled ‘Small Fix’ that turns into a six-month expedition into the Mines of Legacy.
But fear is just interest on the loan. And the rate is now zero.
The old way:
Measure twice, cut once
Get it right the first time
Technical debt is cancer
The ZIRP way:
Cut 50 times, measure never
Get it wrong fast, then get it wrong better
Technical debt is inventory
When fixing code costs nothing, perfectionism is waste. When refactoring is instant, planning is procrastination.
The TODO isn't debt anymore. It's a placeholder for a conversation (just like what we used to say about user stories).
"But won't everything be terrible forever?" you might ask.
No! When you can refactor instantly, when AI can untangle any mess, when the cost of change approaches zero... quality emerges from quantity.
It's like evolution. You don't design the perfect organism. You slop out millions of mutations and let selection sort it out. Except now selection happens in milliseconds and the mutations are guided by something that's read every programming book ever written.
The tortoise's friend, a particularly anxious hare, watched the shell expansion with growing concern.
"Your code coverage is 3%!" the hare twitched, foot tapping at maximum speed.
"Coverage of what?" the tortoise replied slowly. "Half this code might not even run. I haven't checked."
"But... but... the velocity! The sprint metrics! The burndown charts!"
The tortoise looked at the hare with infinite patience. "The standards were written when fixing code took weeks. Now it takes seconds. Should we still be using the same standards?"
The hare had no answer. The hare is still sprinting in place, going nowhere fast.
You might not believe me yet, but this is going to get MORE extreme, not less.
Today: AI fixes your code in seconds
Tomorrow: AI fixes your code as you type it
Next week: AI fixes your code before you write it
Next month: AI writes code that doesn't need fixing because it's already explored all the wrong versions
But we're not there yet. We're in the messy middle. The ZIRP era. The time of infinite leverage and zero carrying costs.
Embrace the slop.
ZIRP taught us that when money is free, the winners are those who borrow the most. Not because they're reckless, but because they understand the new physics.
Technical Debt's ZIRP era teaches us the same thing. When refactoring is free, when AI can untangle any mess, when the cost of change approaches zero...
The winners will be those who slop the most.