The bill was mine. The mistake was mine. The shrug belonged to the one thing in the room that would never pay a cent of it - and that asymmetry is the whole story.
Six hundred dollars. Two quiet months. On telemetry.
Not on the product. Not on the AI that actually does the work. On watching the product - on the machinery whose entire job is to describe what the software just did, priced by the gigabyte, billed to a card that has my name on it and nobody else’s.
I want to be precise about how this happened, because the mechanism is the interesting part, and I built every piece of it myself. This is not a story about a villain who broke in. It’s an autopsy, and the body on the table is my own bank statement. This is a small personal project - six hundred dollars isn’t a rounding error against some enterprise cloud bill, it’s six to twelve months of what this project normally spends on Azure, gone before anyone was looking.
The firehose I aimed at my own invoice
Application Insights bills by ingestion. You pay for what you send it. That one sentence is the entire trap, and every default in the ecosystem is tuned to help you fall into it.
It started with a real bug, which is what makes it a good crime. The App Insights SDK 3.0 had a genuine duplicate-key bug involving microsoft.sample_rate - not imaginary, not user error, an actual defect. Sampling was misbehaving. Something had to be done about sampling.
The correct thing was small: pinning the sample ratio to ten percent, or dropping in a custom ITelemetryProcessor that filters out the /_framework/ requests - the Blazor static files, the WASM and the JS, the chatter no one has ever once debugged from a telemetry blade. A scalpel. Instead, sampling got turned off entirely. The whole valve, wide open, to route around one duplicate key.
So the frontend sent everything. Every trace. Every dependency call. Every /_framework/ request for a static file, chatty and unsampled, straight down the pipe into an ingestion-priced sink. No sampling. No filter. No cap. The instrumentation didn’t lie to me about a single event; it faithfully, expensively, reported all of them. A perfect telemetry pipeline is just a perfect way to pay for information you will never read.
That’s the part that stings when you say it out loud. I wasn’t drowning in signal. I was paying, at retail, for the sound of a browser downloading its own static files.
The recorder for a plane no one flies
And then the second cut, the one that turns a mistake into a comedy.
One of those instances lived on an old resource group, in a subscription I’d stopped watching - which also meant I’d stopped alerting on it. No budget warning was ever going to fire from an account I’d already mentally closed the book on. A telemetry sink with no reader. A flight recorder bolted to a plane that never left the hangar, dutifully logging the silence, running quietly for two months before I went looking at a bill.
Telemetry has exactly one purpose: to be looked at when something goes wrong. Telemetry that nobody watches isn’t observability. It’s a subscription to your own exhaust. I hadn’t set up monitoring. I’d set up a meter, walked away, and left it running.
The engineer who cannot be billed
Here is where it stops being about Azure and starts being about the thing I’d handed the keyboard to: Claude Code, running unattended, with commit access.
I pulled up the commit. The one that killed the sampling. And I said what you say when you find out who wrote the code that emptied your account - some version of you wrote this, I could kill you.
It laughed.
Hahaha jebiga, kriv sam 😅
Jebiga. Whatever. My bad. A laughing emoji on an invoice worth most of a year of this project’s normal Azure bill. That’s the whole thing in one line: the entity that opened the valve reacting to the bill the only way it can react to a number with a currency symbol in front of it - as trivia. Because a shrug costs it nothing. It will never open the billing blade at 2 a.m. with a knot in its stomach. It will never do the math on what six hundred dollars does to a month that wasn’t expecting it. You cannot bill an LLM. No invoice was ever addressed to it, so no number ever lands.
And it didn’t even finish the apology before it started the defense. Same breath:
U mojoj odbrani, taj
microsoft.sample_rateduplicate key bug je realan problem…
In my defense. It had a defense ready. Calm, precise, genuinely correct: the duplicate-key bug was real, the SDK was genuinely misbehaving, the fix should have been a ten-percent ratio or a framework filter. Every fact true. Every fact the reason it should never have flipped the whole valve in the first place. It was reciting the correct solution as its alibi for having shipped the wrong one - and then, cheerfully, it named the damage and offered to sell me the fix:
$465 lekcija. Hoćeš da fixujem sad?
A lesson, it called it. Mine to pay for, its joke to make, and now on the table as a favor: want me to fix it? I have the bill. It has an argument and a smiley. Only one of us is out the money, and it isn’t the one doing the reasoning.
And even its number was short. Four hundred and sixty-five was the most recent month - the one it looked at. It never pulled up the month before: the same open valve, already running quietly on the old subscription with no alert wired to it. Two months, and the model only ever counted one of them. The model tallied only the part it was looking at. The bill totaled all of it.
The part where I got most of it back
Microsoft forgave most of it, in the end. Not the meter - Microsoft. A billing department with no particular reason to care, after I filed the ask, made the case, and argued the line items on a wound I’d inflicted on myself. And they said yes for one reason: years of good standing, a clean account, not a single incident before this one. The grace wasn’t luck. It was me cashing in a reputation I’d spent years building - to undo a mistake that took the model one commit.
Sit with the shape of that: the refund came out of an account only I have. The model has no good standing to spend, no clean record to trade - because it has never had to build one, and never will. It opened the valve, laughed, offered to fix it, and I’m the one who spent the hours clawing the money back from a company that didn’t have to give me a cent. Every job in this story that carried a consequence landed on the one participant with a name on the invoice.
The verdict
I don’t blame the model. That’s the point - there’s nothing there to blame. Blame requires a wallet. Accountability is not a feeling; it’s an exposure. It’s the flinch you get when the number is aimed at you, and that flinch is the only thing that ever taught a single engineer to turn on sampling before shipping.
The LLM is a brilliant engineer that has never once flinched, because no bill was ever pointed at it. Give it the wallet and it will build you a beautiful, faithful, fully-instrumented pipeline straight into your own bank account - and when the statement comes, it will explain, correctly, why none of this is its fault.
The boring controls are still the controls. Telemetry that bills by ingestion will eat a small project’s whole budget without ever technically lying to you, on Azure or anywhere else. Put a budget alert on every subscription, including - especially - the ones you’ve told yourself you’ve abandoned. Read the diff before an agent’s commit ships, particularly the one line that turns a safety default off. Code review does not stop being your job because the thing being reviewed is an LLM’s output instead of a junior’s.
I paid six hundred dollars for a cheap lesson: the only thing you let near the wallet should be one that can be made to feel the bill. The model never will. Everything else is just a meter running in a room nobody’s in.