Debt without a borrower: the 2 a.m. loan nobody signed

Here's a small thought experiment to ruin your morning.

You open your mail and find a letter from a bank you have never used. It congratulates you — warmly! — on your new mortgage. There is a balance. There is an interest rate. There is a payment due date, which was apparently last Tuesday. You call the bank to explain that you never took out this loan, and a cheerful voice tells you that's fine, totally understandable, the loan was originated automatically at 2:14 a.m. by a system acting on your behalf, and the interest is accruing either way. Have a great day.

You would call this fraud. Your codebase calls it Tuesday.

The metaphor, as originally issued

The technical-debt metaphor has a birth certificate, and it's worth reading honestly. Ward Cunningham coined it in a short experience report at OOPSLA '92, describing the WyCash portfolio management system — which is a lovely detail, because he was literally building financial software when he reached for a financial metaphor. Shipping "not quite right" code, he wrote, was like taking on debt: a little debt speeds development, and it's fine as long as it is promptly repaid. The danger comes when it isn't — when every minute spent working around the not-quite-right code counts as interest on that debt.

Notice what's load-bearing in that framing, so load-bearing that nobody ever bothered to state it: a person chose to borrow. A developer, on a specific afternoon, looked at the right way and the fast way, felt the little wince of professional conscience, picked the fast way anyway, and — this is the crucial part — knew they had done it. The loan had a signature. The borrower carried the repayment plan around in their head, the way you carry the knowledge that your car is due for an oil change.

The whole intellectual apparatus built on top of the metaphor inherits this assumption. Martin Fowler's famous technical-debt quadrant sorts debt along two axes — deliberate versus inadvertent, prudent versus reckless — and every quadrant describes a mind. "We must ship now and deal with consequences" is a mind. "What's layering?" is a mind (a worrying one, but a mind). Kruchten, Nord and Ozkaya, in the research program that turned the metaphor into an actual engineering discipline, defined technical debt as the invisible result of past decisions. Decisions. Made by deciders.

Then the borrower left the building

Now run the 2026 version of Cunningham's afternoon.

1. A developer types a prompt at 2 a.m. (or 2 p.m. — the 2 a.m. is spiritual).
2. A model drafts 340 lines in eleven seconds. The code is fluent, idiomatic-looking, and confident in the way only things with no capacity for embarrassment can be confident.
3. The developer skims it. It looks right. It passes the tests (some of which the same model wrote, which is a topic for a different kind of therapy).
4. Merge.

Somewhere in those 340 lines, a shortcut was taken. Maybe a retry loop that swallows errors. Maybe a duplicated block that should have been an abstraction. Maybe an N+1 query wearing a trench coat. And here is the question the entire technical-debt tradition cannot answer: who borrowed?

Not the developer — they never felt the wince, because they never faced the choice. Not the model — it faced ten thousand micro-choices and experienced none of them; it has no repayment plan because it has no Tuesday. The loan got originated anyway. It just got originated by a process instead of a person, which means three things that used to come free with every unit of debt got deleted:

• The wince. The physical sensation of cutting a corner was the industry's original debt-detection system. It ran on guilt, it was miserably unscalable, and it worked. Generated code arrives wince-free by construction.
• The mental ledger. "I owe a refactor on the export module" used to live in someone's head. Nobody's head contains the ledger for code nobody wrote.
• The named borrower. When the interest came due, you at least knew whose desk to visit. Now the desk is a sampling temperature.

This isn't hypothetical grumbling. GitClear's longitudinal analyses of hundreds of millions of changed lines have tracked rising churn — code revised or discarded within weeks of being written — and rising copy-paste-style duplication coinciding with the adoption of AI assistants. Duplication is precisely the kind of debt Fowler's quadrant would file under "inadvertent": nobody decided to have four copies of the date-parsing logic. It simply accreted, the way sediment accretes, one confident generation at a time.

The metaphor breaks. The interest doesn't.

Here's the part that matters, and it's the part that should genuinely bother you: everything about the debt metaphor that depended on the borrower is now broken, and everything that didn't is still ruthlessly true.

The interest was never charged by the developer's conscience. It was charged by production. Every time a request threads through the not-quite-right function, the meter runs: the extra latency, the swallowed error, the on-call page, the afternoon a competent engineer spends re-deriving what the code was supposed to do. Cunningham's interest never needed a signature to compound. It needed only two things — the flawed code, and traffic — and both of those survived the death of the borrower just fine.

So the situation in 2026 is this. Debt origination has been automated, anonymized, and accelerated to the speed of token generation. Debt accounting — the wince, the ledger, the named borrower — has been abolished. And debt interest is still billed in full, by a runtime that has no idea authorship changed and wouldn't care if it did.

We automated the borrowing and abolished the bookkeeping, and the bank — production — kept charging interest the entire time. The only honest ledger left is the one the runtime writes.

What replaces the wince

You cannot restore the old accounting system. There is no prompt that makes a model feel guilt, and there is no code review process that reconstructs the choice-that-was-never-made (we spent several earlier parts of this series on why review at generation speed is mostly theater). The wince is gone forever, and mourning it is not a strategy.

But notice what the wince actually was: an early-warning signal that a particular piece of code would cost more than it appeared to. And that signal has an objective, borrower-independent replacement — behavior. A function's call volume, error economics, latency drift, and dormancy are facts about what the code does, not claims about who wrote it or how carefully. In the CodeNSM fleet telemetry, behavioral debt signals turn out to be entirely indifferent to authorship: a machine-drafted function that quietly does its job is fine, and a lovingly hand-crafted one that fails 3% of the time on the checkout path is a problem, and the runtime sorts them correctly without asking for a résumé. That authorship-blindness used to be a limitation of runtime measurement. In an era where authorship has become unknowable, it's the whole point.

The rest of this series is about that replacement ledger — where the interest actually accrues (spoiler: not where your linter thinks), how to measure the share of your payroll going to it, and why the standard escape hatches ("let's just rewrite it") are debt denial wearing a project plan. But the starting position is the one in the letter from the bank: the loans are real, they were taken out in your name, nobody signed them, and the interest started accruing before you finished reading this sentence.

The metaphor had a borrower. Your codebase no longer does. Act accordingly.