Why I Track AI Costs I Don't Pay

I pay a flat monthly subscription for my AI coding assistant. The bill is the same every month no matter how much I use it. So when my own tracking tool, DevPulse, tells me that a single work session "cost" $265, or that a month of sessions adds up to far more than what I actually pay, it is fair to ask: why do I care? I'm not being charged that. The numbers are imaginary.

It's a good question because the calculated cost is not real. However, the thing being measured is very real indeed.

I'll admit that having this data at all is unusual. Almost nobody on a flat monthly plan tracks what their AI sessions consume. There's no invoice to raise the question, so most developers never think about counting tokens. Out of sight, out of mind. Moreover, I've been asked more than once whether it's even sane to measure something I'm not paying for by the unit. And that is a fair observation, up to a point.

The truth is that measuring things other tools quietly ignore is the whole reason DevPulse exists. Once the numbers are sitting in front of you, they start telling you things you never even thought to look for.

That's today''s story. What I learned about the real, hidden costs of AI development.

On a subscription, you don't have a budget in dollars. You have a budget in usage. Usage is a rolling allowance of how much the assistant will do for you before it says "you've reached your limit, come back later." Every bit of work draws that allowance down. So the "cost" my tool records isn't a bill. It's like the fuel gauge on a gas pump rolling up gallons and dollars. It tells me how fast I'm burning toward the moment the assistant stops and makes me wait. Unfortunately, that is usually right in the middle of something important.

That disruption is where the cost of AI actually shows up on a flat-rate plan. It's not on a credit-card statement. It's less tangible than that, and more immediate than a monthly invoice. It is lost time and work that stalls at the worst moment.

It's having to refocus and regain momentum after the timeout expires.

I began to wonder: where does all that fuel actually go? Claude Code used the data collected over a couple of months by DevPulse to create this graphic. Yeah, it cost a few tokens, but I think it's worth it.

The picture turned out blunter than I expected. Each bar in the chart is one of 78 logged AI coding sessions, the biggest consumers on the left. The work is metered in units called tokens. You can think of them as the marks on that fuel gauge. The blue segment of each bar is the part that stopped me short.

Before I explain why, a quick bit of plumbing, in plain terms, is in order.

An AI assistant has no memory of its own between messages. When it needs to answer your next question, it has to re-read the entire conversation in that session so far. That includes every message, every file it looked at, every result it produced, starting from the top. That happens every single time. That blue segment in each bar is the re-reading part, not the working part.

The little grey feet at the bottom of the bars are the only part that's genuinely new: your latest request and the assistant's fresh answer.

Look at that chart. Across 78 recorded sessions, 94% of everything I spent in those sessions went to the blue; that is, I spent 94% of my tokens just re-reading previous conversations, not producing new work.

Put plainly: for every hundred units of my usage allowance, about ninety-four went just to remind the assistant what we'd already said.

The story behind the story

Here's the part that actually matters for how you work. That re-reading cost isn't fixed — it grows over time. The longer a session runs, the more conversation there is to re-read, so every new turn costs a little more than the one before it. A session that's been going for three hours spends tokens re-reading three hours of history on every small request. The cost of continuing a conversation quietly compounds.

You can see it in the shape of the chart. A handful of long, sprawling sessions on the left tower over everything else. My eight biggest sessions account for 42% of all the tokens I burned across months of work.

The tallest bar is one you may recognize if you read my last post: the "$265" session. That session used 375 million tokens,and 93% of that was spent just re-reading the same context over and over.

It wasn't expensive because the work was hard. It was expensive because it ran long and carried a mountain of conversation on its back the entire way.

What I said about lack of discipline in the previous blog post is doubly obvious when seen in this light. Rambling on and on has a real cost. That cost doesn't show up in a credit card bill. It shows up when a session limit is reached and your work flow is disrupted.

What we just learned says about using AI well

So what does this tell us about using AI wisely?

The single most useful habit I've picked up is a boring one: start fresh when you start something new. These days, when I finish a task, I have the assistant write down what matters — decisions, current state, next steps — and then I clear the conversation and begin the next task clean.

I like the way Claude Code expressed it. A new session doesn't drag the old one's mountain behind it.

On the chart, that's the whole difference between a short bar on the right and one of those giants on the left.

Unfortunately for me, it can't be boiled down to a rule a machine follows for me, because it doesn't know whether the next thing I am about to do is really a continuation or a fresh start. That's a judgment call I have to make, and it has to be made at the seam between tasks.

Nonetheless the payoff is real and durable: more work before you hit a wall, and — a bonus I didn't expect — sharper answers, because an assistant that isn't wading through three hours of history pays closer attention to the thing right in front of it right now.

There's an important footnote here, the same one from the $265 story. A tool that measures costs only helps if you act on what it shows. DevPulse can draw me this chart, but it can't clear my context for me, and it can't tell me where one task ends and the next begins. That part is discipline. It's putting on the Project Manager hat and pulling it down tight around my ears. Having a chart just made the cost of skipping that discipline impossible to ignore.

If you, like I am, are using AI to build things, you're probably on a flat fee plan too, and it's easy to assume that makes your excess usage free. It isn't. You're spending a real, limited resource on every turn. Unless you are mindful and alert, most of it goes just to carry the conversation forward, and that, as I see it, ain't free at all.

Spend your AI fuel deliberately, not just because you don't see the meter running on the pump.