The Dev Tools I Actually Pay For (and the Ones I Cancelled After a Month)

I keep a note in Apple Notes, embarrassingly, titled "subscriptions to reconsider," and every few months I actually open it and go through the list with a cold eye. Most people don't do this, which is how you end up paying for four things that do the same job because you forgot you signed up for the third one during a free trial eight months ago. Here's what survived my last audit, what didn't, and why — with actual dollar figures because vague enthusiasm isn't useful to anyone deciding whether to spend their own money.

The ones I'd renew without thinking twice

Claude Code, roughly $20-100/month depending on the plan. I resisted paying for an AI coding subscription for longer than I should have, mostly out of a stubborn "I don't need a robot to write my code" attitude that I now recognize as pure ego. What changed my mind was using it for a genuinely tedious task — migrating about sixty files off a deprecated internal logging wrapper to a new one with a slightly different API. That's exactly the kind of work that's mechanically simple but soul-crushing to do by hand across dozens of files, and it's exactly where it earns its keep, sitting in the terminal, reading actual file context, making the edit, running the tests, iterating when something breaks. I still write the architecture decisions myself. But for the "I know exactly what needs to happen, I just don't want to type it sixty times" category of work, it's paid for itself many times over in reclaimed afternoons.

Linear, around $8/user/month. I was a Jira holdout for years — genuinely thought ticket trackers were all roughly interchangeable and the complaints about Jira were exaggerated. Then I used Linear on a small team project and the keyboard-driven workflow alone converted me; you can triage, assign, and move a dozen issues without touching the mouse once, and issue creation from a GitHub PR title is close to instant. It's a small monthly cost that I notice in daily friction reduction more than almost anything else on this list, which is a strange thing to say about project management software.

Raycast Pro, around $8/month. This one is harder to justify on paper and I know it. The free tier does most of what people need. What got me onto Pro was the AI commands feature combined with clipboard history sync across my two machines, plus custom window management snippets I built for my specific monitor setup. It's a quality-of-life purchase more than a productivity one, and I'll be honest that if I were being ruthless about the "reconsider" list, this is the one most likely to get cut first if money got tight. I keep it because the friction reduction compounds across dozens of small interactions a day, and that adds up in a way that's hard to demonstrate in a screenshot.

JetBrains All Products Pack, a few hundred dollars a year. For anything Java or Kotlin, IntelliJ is still meaningfully better than the alternatives in my experience, particularly for large codebases where the refactoring tools and the debugger just work in ways I haven't found matched elsewhere, VS Code included. I switched to VS Code plus extensions for most of my TypeScript work years ago, but the day I have to touch a Spring Boot service, I'm opening IntelliJ, no contest.

GitHub Copilot, effectively bundled into a Copilot Business seat at work. This is the one I have the most mixed feelings about but still keep. The inline completions are genuinely good for boilerplate — test scaffolding, repetitive config, the fifth CRUD endpoint that looks like the first four. I don't reach for it on anything that requires real judgment, and I've caught it confidently suggesting deprecated API patterns often enough that I don't fully trust it unsupervised. But as a faster autocomplete, it's worth the money.

The ones I cancelled

Notion AI, a small monthly add-on. I wanted to like this. In practice I found myself using it maybe twice a month, mostly to summarize a meeting transcript, and paying a recurring fee for an occasional-use feature stopped making sense after the third billing cycle where I hadn't touched it at all.

A cloud-based Postman team plan. We moved most of our API testing to .http files checked directly into the repo, run through the VS Code REST Client extension or curl in a documented script, and it turned out to be both free and better for our use case, because the collection lives in git, gets reviewed in PRs, and doesn't drift out of sync with an external tool's cloud state. I still use Postman's free desktop app occasionally for quick exploratory poking at a third-party API, but paying monthly for team sync stopped being justifiable once our workflow moved into the repo itself.

LogRocket, at the tier we were on. Good product, genuinely — the session replay quality is excellent and the network request correlation with replay is nicely done. But we already had Sentry doing error tracking and had built our own lightweight metrics pipeline for performance, and LogRocket ended up overlapping maybe 60% with tools we were already paying for. When budget review season came around, it was the obvious cut, and six months later I can't say I've missed it.

An AI-powered code review bot. This is the one I feel most conflicted about cancelling because the pitch was genuinely appealing — automated PR comments catching style issues and potential bugs before a human reviewer even looked. In practice it generated a lot of comments that were either things our linter already caught (redundant) or stylistic nitpicks that didn't matter (noise), and it created a weird social dynamic where people started treating "the bot approved it" as a substitute for actually reading the diff. We cancelled it, kept our linter and our human reviewers, and nobody has mentioned missing it since.

The pattern I've noticed

Looking at that list, the tools that survived all share one thing: they replace a specific, recurring friction I could name precisely — "manually editing sixty files," "waiting for issue triage," "context-switching to find a snippet," "debugging a large Java codebase without proper refactoring support." The tools that got cancelled were ones I adopted because they sounded good in a demo or a tweet, without first being able to articulate the exact pain they'd remove. Now, before I start a new subscription, I make myself write one sentence: "this replaces [specific task] which currently costs me [specific time/frustration]." If I can't fill that in convincingly, I don't sign up, or I use the free trial and set a calendar reminder for the day before it converts to paid, which has saved me more money over the years than any of the tools themselves.

The audit itself is the actual habit worth keeping

None of this is really about any specific tool on the list, and I fully expect half of these to look dated in another two years as the market shifts and new categories of tools emerge, especially on the AI side where the pace of change makes any specific product recommendation a little perishable. What's stayed constant is the quarterly ritual itself: sitting down, pulling up a bank statement or a list of active subscriptions, and asking honestly whether each one earned its keep in the last three months, not whether it might theoretically be useful someday. That single habit, more than any individual tool choice, is what keeps my actual spending aligned with my actual workflow instead of drifting slowly upward the way subscriptions tend to when nobody's checking. If you don't already do some version of this audit, I'd genuinely start there before you start comparing individual products, because the discipline of asking the question regularly matters more than getting any single answer right the first time.