My AI bill made more sense after I counted retries

I started with the bill, not the model names

A yearly AI review is most useful when it answers a practical question: am I getting more useful work from the money I spend? A lower bill is not automatically progress if I have stopped building things. A higher bill is not automatically waste if it supports a demanding project.

For this walkthrough, I use an illustrative personal ledger rather than claim these are actual account results. It shows a pattern worth checking in your own history: usage rises, spending peaks, and better habits bring costs back down.

I put twelve months of spending in one place

First, I collect monthly charges and usage records. I separate money added to an account from money actually consumed by requests. A balance top-up is not the same thing as that month's usage, and mixing the two can make a quiet month look expensive.

MyRelay helps with this review because members can see every request's tokens and cost. I use those details to reconcile usage with spending, then group the figures by quarter to make the overall direction easier to see.

• In the first quarter, 300 requests cost $36.
• In the second quarter, 600 requests cost $60.
• In the third quarter, 900 requests cost $54.
• In the fourth quarter, 1,200 requests cost $42.

The annual total is $192 across 3,000 requests. The important observation is not just the total: the final quarter has four times the requests of the first, but costs only $6 more.

I checked what those requests actually accomplished

Next, I sort a manageable sample into activities: coding, study, writing, and experimentation. I do not attempt to classify every request perfectly. I want to understand which activities grew and which produced results I actually used.

I also distinguish an individual request from a completed task. One debugging session might involve ten requests, while one explanation might be useful immediately. Falling cost per request can hide a growing number of attempts per task.

For a student, a useful result might be an explanation they can reproduce without assistance. For a developer, it might be a reviewed change that passes tests. Neither is captured by request volume alone.

I investigated the quarter when spending peaked

The second quarter deserves a closer look because spending rose faster than my comfort level. I inspect its busiest sessions and look for repeated prompts, large inputs, long outputs, and retries after answers that missed the point.

Then I separate price changes from habit changes. A different model mix can affect the bill, but so can repeatedly sending the same background material or asking for a complete rewrite when one paragraph needs fixing.

I mark avoidable retries separately from useful iteration. Correcting an unclear request is different from deliberately exploring several approaches. The aim is to remove accidental waste, not discourage thinking.

I matched model choices to the work

Next, I identify tasks that do not need my most expensive option. I might test Gemini 2.5 Flash on short summaries or straightforward extraction, then compare the results against my usual approach using the same small task sample.

I judge the whole task cost, including corrections. A cheaper first answer is not a saving if it needs several repair attempts. I also shorten repeated context and request a specific output length when a brief answer will do.

I turned the review into a modest spending plan

Finally, I use the last quarter as a starting point, not a promise. Its $42 total suggests a $14 monthly baseline, but deadlines and unfamiliar projects need room. I set a working budget with a small buffer and review it monthly.

If your records are scattered, create a MyRelay account to keep supported model usage under one key and one budget. Wherever you track spending, keep the review simple: total cost, useful outcomes, and one habit to change. That is enough to make next year's bill less surprising.