We must ship now and deal with consequences

This is a really silly point to write, and obviously disprovable. Here's a really simple and realistic example:

You've just deployed your app. It's perfect... except there's this huge performance issue with one of the most important pages. Your app's just gone up on Slashdot, TechCrunch, and everywhere else. Zillions of people are using it. You have two options:

1) An ugly evil hack that will sort out the performance for that page. Total time: 30 minutes.

2) A re-architecting of that part of the application that will cleanly resolve the performance problem with efficient use of caching. Total time: a week.

If you choose option 2, you're a moron (sorry, no other way to put it). Option 1 obviously increases your net worth. Yes, you need to go back and do 2) as well, but this is a pretty damn good scenario where it makes a lot of sense to write and ship bad code knowingly. And yes, it does increase your net worth - those zillions of users might stick around instead of claiming your app's broken and moving on.

  What is this talk of 'release'? Klingons do not make software 'releases'.
  Our software 'escapes' leaving a bloody trail of designers and
  quality assurance people in its wake.

Heh, this always gets me to laugh. I've been on both sides of this issue though: I worked at a place that shipped code and their version 3 release is shaping up to be what their 1.5 release should have been. But I can also get to the point of paranoia, "I can't release this! it still has bugs!"

Maybe we just need to have a "release determination board" filled with 50% pessimists and 50% optimists. That way, you'd have a huge argument over when to release.

To release is risk, but is risk itself imprudent? I doubt it.

There's a lot of evidence from successful people that good enough is good enough.

We all create it. Sometimes for better reasons than others.

It's everywhere, it's costly, and it sucks.

Then I thought about another scary truth that wasn't mentioned in either post:

Much of it never has to be paid back.

That's right, we create "technical debt", but so what?

I often maintain code that's 5 to 10 years old with as many as 100 mods. But just as often, I come across something 10 years old that looks like crap with no mods. How can this be?

Because it works. Somebody wrote a function they needed 10 years ago, and it's apparent today that they didn't know what they were doing. Since then many others have called that function. You want to rewrite it, but you dare not touch it. Why risk production without a request?

It's ugly, it sucks, but it works and has always worked. I bet about half the "technical debt" I've encountered is like this, debt that will probably never be paid back. Then is it really debt at all?