The Tools Worth Paying For, and the Ones That Are Not

Your card statement has eleven software line items on it and you could not, right now, say what three of them actually do for you. None arrived as a decision; they arrived one plausible free trial at a time, and now they renew quietly on the eighteenth of every month.

Here is the audit, organised by category rather than by brand, because brands churn and categories do not. Prices move constantly, so treat every figure below as my own judgement of a typical band rather than anyone's current card.

The short version: most independent developers underpay for feedback loops and overpay for things that produce artefacts. An artefact you buy once. A feedback loop you rent forever, and it is the rent worth paying.

Agent and model access

Worth it, and the one line item where paying more usually pays back.

Individual tiers for serious agent access run from roughly twenty dollars a month at entry to somewhere north of a hundred at the top, with usage-based API billing sitting alongside. The gap is not just quota. It is model quality, context size, and how often you get throttled mid-task.

Do the arithmetic on your own time. Say your time is worth £60 an hour, which is modest for a competent freelance developer in the UK and probably below what you would quote a client. The step from an entry tier to a higher one might cost sixty or eighty dollars a month, call it around £60. That is one hour.

If the better tier saves you one hour a month — one debugging spiral that resolves in two turns instead of twenty — it has broken even. In practice it saves much more, because the failure mode of a weaker model is not slightly worse code. It is a confidently wrong patch that costs you an afternoon of review and rework. That afternoon is the real price.

Error monitoring and log aggregation

Worth it, and more worth it than when you wrote everything yourself.

When you hand-write a system you carry a mental map of its weak points. You know the function that does date maths badly. You remember where you skipped a null check at three in the morning. That intuition is a debugging tool, and it is exactly what you lose when an agent writes half the code.

AI-built code fails in ways you did not anticipate, in places you have not read carefully, and you will not have a hunch about it. So buy the hunch. A hosted error tracker giving you the stack trace, the release, the user and the frequency is doing the job your memory used to do. Log retention beyond a day is the same argument extended. Free tiers are genuinely usable at small scale; the paid step buys retention and alert routing, and you will want both the first time something breaks on a Friday night.

CI and preview deployments

Worth it, and specifically more valuable than it was two years ago.

An agent's output quality is bounded by the quality of the signal it gets back. If your test suite takes eleven minutes, the agent is working blind — it makes a change, guesses whether it worked, moves on. If the same feedback arrives in ninety seconds, it iterates against reality. Paying for faster runners is not developer convenience. It is buying agent accuracy.

Preview deployments per branch matter for the same reason. Half of what an agent gets wrong is visible in four seconds of looking at the actual page, and invisible in a diff.

A database host with point-in-time restore

Worth it, and insist on the restore specifically.

The scenario is concrete. Eleven at night, the agent has written a migration, it looks fine, you approve it. It drops a column a background job was still writing to. With nightly backups you lose a day of data and notice in a week. With point-in-time restore you rewind to 22:58 and lose ninety seconds. Managed Postgres with PITR at small tiers tends to sit around fifteen to thirty dollars a month. That is insurance priced at roughly nothing.

The ones that are not

Design tooling and UI kits. Not as a subscription. A component library is an artefact: once you have it, it sits in your repo and keeps working, and it does not improve because you kept paying. One-off licences for good kits are generally in the low hundreds of dollars and that is a fair trade. The same thing rebadged as twenty a month is not. Open source covers most of it anyway.

AI code review bolted onto your agent. Usually not. You already pay for a frontier model; asking it to review a diff costs you a prompt. The category exists because reviewing your own agent's work feels uncomfortable and a third-party badge on the pull request feels like independent verification. Often it is the same class of model with a different system prompt. Spend the money on tests, which catch a different class of problem and keep catching it.

AI project management and prompt-management SaaS. Almost never. Your prompts belong in version control, in the repository, beside the code they operate on, so a change to the prompt lands in the same diff as the schema change it depends on. A separate hosted store with its own versioning is a synchronisation problem you invented and now pay for. "AI project management" is generally a Kanban board with summarisation attached, and you have a markdown file.

Scaffolding and boilerplate generators sold as products. No. This is precisely the thing the agent does.

Analytics, domains, email

Analytics: one, not three. The common failure is a product analytics tool, a page-view counter and a session replay tool, all installed, all billed, none consulted more than once a fortnight. Keep the one that answers the question you actually ask, which for most small products is whether anyone used the thing you shipped last week.

Domains and transactional email are trivial. A domain is roughly £10 to £15 a year; an email provider at small volume is single figures to low tens of dollars a month. Running your own outbound mail is not a saving, it is a hobby with deliverability homework.

How to decide

The cancel test. For each line item, ask what breaks if you cancel today and whether you would notice within a week. Nothing breaks and you would not notice: that is your answer. Something breaks in a way you would notice within an hour: load-bearing, keep it.

The annual-plan trap. Annual billing saves fifteen or twenty percent and converts a reversible monthly decision into an irreversible yearly one. The tools you are most tempted to prepay for are the new ones you are least sure about. Pay annually only for things you have already run monthly for six months.

The free-tier trap. Some products are generous at zero and steep just past it, so the bill arrives at exactly the moment your project starts working. Before building on a free tier, look at the first paid step and ask whether you would accept that price at ten times your current usage. If not, you are building on something you will have to migrate off under time pressure, during the only week your product has ever been busy.

A worked monthly budget

Assumptions: one solo developer, two deployed products, a few thousand monthly users between them, no team seats.

Agent and model access, higher individual tier   $100
Error monitoring, entry paid tier                 $30
Log retention beyond the host's default           $10
Hosting tier with CI and preview deploys          $20
Managed Postgres with PITR                        $25
Analytics, one tool                               $10
Transactional email                               $15
Domains, two, amortised monthly                    $3
                                                 -----
                                                  $213

Roughly half of it is the agent. At an effective rate of $75 an hour, the whole stack costs under three hours of your time a month, so if it saves you a single day it is not close. Note what is absent: no UI kit subscription, no review bot, no prompt manager, no scaffolding product, no second and third analytics tool. Those are the ones that quietly take the total past four hundred without changing what you can do.

The pattern underneath all of it is that the things worth renting tell you the truth about your software while it is running — errors, logs, test results, restore points. The things not worth renting hand you an object and call it progress. An agent will produce objects all day. Knowing whether they work is the part you still have to buy.