Betting on a Tool Before You Needed It
A tool bought because you need it today is a repair bill. Bought early, the same tool is practice — and practice is the only thing you still have on the day it has to hold.
Part 1 of 3.
The expensive way to buy tooling is after you need it.
That sounds like a budgeting tip. It isn’t. Buy a tool for the problem you already have and you’re paying retail for a fix — a transaction, nothing more. Buy it before the problem exists and you’re buying something else entirely: time to learn the tool before the tool has to save you. The difference is the subject of this series, and I learned it by almost doing it the expensive way.
In 2020 I was writing Java — Spring Boot — before I joined the team that sets up the rest of this story. And I already knew, from older Java work — Android development in 2016 and 2017 among it — that for Java, almost no other IDE matched JetBrains.
I knew it from trying, not from a forum post. I’ve tried other IDEs and code editors, and given each a real shot. Every time something was missing — not a feature I could point to on a comparison table, just a feeling that the editor was there but the answer was slower to show up.
So on that Spring Boot job I bought JetBrains Ultimate, with my own money, before any employer had a reason to spend theirs. Not everything I lean on later in this series was bought that way; I’ll say so when it comes up.
The Objection
Yes… I know. The codebase didn’t justify the price.
It was a fairly ordinary Spring Boot app. Nothing in it screamed for the heavy artillery. A lighter setup would have compiled it, run it, and probably debugged it too. So what was I paying for?
Measured against the code I had, the objection is right, and I overpaid. But I wasn’t measuring against the code I had — I was measuring against the code I didn’t own yet.
Bought for code you don’t own yet, it’s a hedge — invisible at the checkout, obvious six months later.
The Reflex
The hedge bought a reflex, not a feature.
I started to lean on the tool until it answered. Ctrl+F5 — rerun — became a habit before I decided to form one: change a line, rerun, change another, rerun.
I abused it from the start, and I’d do it again later, on a different stack, in ways that mattered more.
For now the habit was the point — a shorter distance between “I wonder” and “I know,” paid for before any code existed that would force me to need it.
Two Proofs
A bet like that proves itself twice, never on the day you make it.
The first proof is daily work — the ordinary days, where the reflex you bought gets used often enough that it stops feeling like a purchase. The second is fire, where there is no time to learn anything, and the only thing you get to use is what you already lean on.
In 2020 I had neither proof. I had a feeling, a habit forming around one key, and a license that cost more than the code in front of me justified.
The first proof came later, on a legacy JavaScript codebase — two test runners, a suite nobody had loved in years, and a stack I had never touched.