Testing has a blind spot, and it's not the code, it's the habit. Ben Linders' piece on sustainable testing strategy lands at a moment when most teams are still treating the test suite like a sacred cow, running everything just because they always have. That's not diligence; that's waste. The core insight here is refreshingly practical: skip what doesn't need running, fail fast when something breaks, and let the scope of your changes dictate the scope of your verification. If you've ever stared at a 20-minute pipeline for a one-line fix, you already know the pain. The solution isn't more hardware or more patience; it's a deliberate, energy-aware approach to what "enough" actually means.
What stands out is the emphasis on tracking energy use per test and leaning on static code analysis to find the real offenders. Most teams measure time, but time is only a proxy for the deeper cost. A test that runs in two seconds but spins up three containers and hammers a database is far more expensive than its duration suggests. Linders is pointing at a future where you treat test execution like a utility bill, you audit it, you question the big line items, and you cut the always-on services nobody remembers. That's not just good for the planet; it's good for your velocity. Slower, heavier suites mean slower feedback, which means bugs live longer and cost more to fix. The same logic that makes a test suite sustainable also makes it faster and more reliable. That's not a compromise; that's a correction.
If you're skeptical about the feasibility, start small. You don't need to overhaul your entire CI stack by Friday. Pick the flakiest, slowest, or most redundant suite you own and ask one question: does every test in here justify its runtime and resource draw? You'll likely find that a meaningful chunk are either covered elsewhere, testing implementation details that don't need guarding, or simply too brittle to trust anyway. Static analysis can flag the dead weight, and energy tracking gives you a tangible number to rally around. But the deeper point is this: testing is a risk management activity, not a virtue signal. Every test you write is a liability until it proves it can catch a real regression. Treating it like a checkbox is how you end up with a suite that takes an hour, breaks on Mondays, and still misses the bug that matters.
The real takeaway to quote: "A test that isn't run is free; a test that runs without reason is debt." So the next time you're about to run the full suite out of habit, stop and ask what you're actually protecting. Then build the mechanism to prove it. The teams that win this decade won't be the ones with the most tests, they'll be the ones who run the fewest that still catch everything that matters. That's the shift worth making, one energy meter and one deleted redundant spec at a time.