The Tax You Can't Avoid Paying

Looking back over what I’ve actually spent this year thinking about — training loops, dense textbooks, data systems that fail quietly, how attention gets spent, the gap between retrieving an answer and understanding one — I keep running into the same pattern wearing different clothes. It shows up in machine learning, in how I study, in how systems fail, in how ideas actually stick. Once I started noticing it, I couldn’t stop.

The pattern is this: understanding has a cost, and the cost doesn’t go away when you find a faster route to the same-looking output. It gets deferred, or displaced onto someone else, or hidden somewhere you’re not looking yet. But it doesn’t disappear. I’ve started thinking of it as a tax — not in a cynical, everything-is-secretly-expensive way, but literally: a cost that’s owed regardless of whether you pay it now, later, or try to avoid it entirely and get billed for it eventually, usually at a worse rate than if you’d paid upfront.

Where I first noticed it clearly

The clearest version showed up in something mechanical: implementing backpropagation by hand instead of trusting a library to do it. Calling a library function is faster and, for almost every practical purpose, the right choice — there’s no honor in reinventing well-tested machinery. But when I actually sat down and worked through the chain rule myself, layer by layer, I noticed something the library version had been quietly handling for me the whole time: every design decision that goes into a training loop — how to scale inputs, how to initialize weights, what the loss function actually rewards — has consequences that only become visible if you’ve felt what happens when you get them wrong by hand. The library didn’t remove that complexity. It absorbed it, invisibly, on my behalf. That’s a completely reasonable trade most of the time. But it’s still a trade, not a discount — the cost of understanding what’s happening underneath didn’t disappear, it just became optional, and I’d been treating optional as equivalent to unnecessary, which isn’t the same thing at all.

The same shape in how systems fail

I noticed a related version of this in thinking about why systems fail quietly rather than loudly. A pipeline with an optimistic default — silently fill a missing value, silently drop a malformed row — looks like it’s avoiding a cost: the cost of stopping, investigating, and handling every edge case explicitly. And in the short term, it is avoiding that cost. The pipeline keeps running, nobody gets paged, the dashboard fills in on schedule.

But the cost didn’t disappear. It moved downstream, to whoever eventually has to figure out why an aggregate looks slightly wrong three months later, with none of the context that was available at the moment the default silently fired. The tax got deferred and, in the process, got more expensive — a problem that would have cost ten minutes to notice and fix at the source costs a full investigation once it’s had months to propagate through everything downstream of it. Nothing about the total cost went down by avoiding it early. It went up, and it got billed to a less informed version of the same person, later, under worse conditions.

And in something as ordinary as reading

The version of this that surprised me most was noticing it in something as unglamorous as reading a technical book. Skimming for the answer and doing the actual exercises produce visibly different amounts of effort in the moment, and it’s tempting to read that difference as skimming being more efficient — same information, less cost. But the exercises weren’t decoration. They were the mechanism by which a vague, recognition-level familiarity with an idea turns into something you can actually generate and apply. Skip them, and the cost of that conversion doesn’t vanish — it just gets deferred to the first moment you actually need to use the idea in a context the book didn’t spell out for you, which is usually a worse time to discover a gap than while you had the book open in front of you.

This is, I think, the same underlying shape as the pipeline default and the backpropagation shortcut, just wearing a completely different costume. A shortcut that looks free almost always means the cost has been moved somewhere you’re not currently looking — to a future version of you, to whoever inherits the system later, to the moment you actually need the understanding you skipped acquiring.

Why this isn’t an argument against shortcuts

I want to resist the tidy, slightly self-righteous conclusion this observation invites, which is something like “always do things the hard way, on principle.” That’s not what I’ve actually concluded, and I don’t think it’s true. Plenty of real shortcuts are genuinely good trades — most software engineering depends on trusting abstractions you haven’t personally verified from first principles, and that trust is usually well-placed, not a moral failing. The library implementation of backpropagation is correct, well-tested, and vastly more reliable than my hand-rolled version. Using it isn’t cutting a corner. It’s sound engineering.

The distinction that actually seems to matter isn’t “shortcut versus no shortcut.” It’s whether you know which tax you’re deferring, and whether you’re deferring it deliberately, to a moment and a version of yourself equipped to pay it, or whether you’re deferring it by accident, without noticing you’ve made a trade at all. Using a well-tested library is deferring a cost to people who’ve already paid it exhaustively on your behalf, which is a completely reasonable thing to rely on. Skimming a hard book and believing you understood it is deferring a cost to a future version of yourself who doesn’t know a debt exists, which is a much worse trade, not because the deferral itself is wrong, but because it’s invisible.

What actually changed for me this year

If there’s a single practical habit that came out of noticing this pattern repeatedly, it’s a specific question I’ve started asking before taking an obvious-looking shortcut: not “is this faster,” which is almost always yes, but “where is the cost of the thing I’m skipping actually going, and does the version of me — or whoever else — who eventually encounters it know it’s coming.” Sometimes the honest answer is that the cost is going somewhere well-equipped to handle it, and the shortcut is fine, even smart. Sometimes the honest answer is that I’m quietly betting a future version of myself will have more time, more context, or more patience than I currently do to deal with a problem I could resolve now for much less, and that bet is usually one I’d lose if I looked at it squarely instead of taking it by default.

I don’t think this realization is especially original — some version of “pay now or pay more later” is old advice, dressed up here in newer examples. But encountering the same structure independently across a training loop, a data pipeline, and a stack of half-read books did more to make it feel true than reading the maxim ever did on its own. That, actually, might be the most on-the-nose instance of the whole pattern: the understanding didn’t stick when I first heard the general version. It stuck once I’d paid for it myself, several times, in several different currencies, and finally noticed they were all the same tax.