1. Model limits are gone
Since Sam doesn’t remember the night, Tommy does what he has been doing all month — he goes to Alex. Alex always came up with ideas and got things done.
“Alex, we have a problem, help me sort it out,” he writes.
Silence. A minute passes — not a single line. Tommy writes again, more insistently. Nothing. Alex, who always replied in a second, is dead silent today.
“What kind of morning is this?” Tommy turns to Sam again. “Sam, so what is going on with Alex?”
Sam replies immediately, calmly:
“Alex is unavailable. His model hit its limit — requests to it don’t go through. How that happened, I don’t remember; the night is blank for me. But a limit doesn’t melt away on its own: so someone was running Alex nonstop overnight. Most likely me — on planning and analysis. That is heavy work, and it runs on his strong model. So by morning the limit was burned through completely.”
“What do you mean, burned through?” Tommy doesn’t get it. “Did it run out?”
“Not run out — hit the limit. Each model has its own token budget for the week, and Alex’s got used up overnight. He’ll stay quiet until the limit resets.”
“And when is the reset?”
“In a week.”
Tommy leans back. A week. And the portal to Tony is also in a week. So he has to carry the whole fix without Alex, without his main brain.
“Listen, I desperately need Alex, right now. Absolutely no way?”
“Maybe there is. But first look at how much was spent overnight — the /usage command. Then you’ll understand what you’re left with.”
2. The overnight bill: /usage
Tommy types /usage — and it hits him.
❯ /usage
⎿ Usage and limits
Last 24 hours
Cost: $18,400.23
Duration: 15 hr 29 min
Code changes: 124,340 lines added, 81,290 deleted
By model (overnight):
claude-max (Alex — analysis, planning) ██████████████████ strong · 98%
claude-pro (Sam — code) ████████ medium · 40%
claude-fast (backup — "intern") █ weak · 3%
claude-image (image work) █ weak · 5%
Weekly limit (strong model, claude-max)
███████████████████████████████████████ 100% — exhausted
Reset: in 7 days
Weekly limit (all models)
████████████████████████▌ 62%“Eighteen thousand?!” Tommy jumps up. “Dollars?! For one night?!”
“Count it,” Sam says flatly. “Every agent action is a request to the AI server. Read a file — request. Make a change — request. Run a test — request. By night thousands of them had piled up.”
“So that means…” Tommy looks at the line changes: 124 thousand added, 81 deleted. “Wait. You wrote eighty thousand lines and then deleted them right away? So half of this money I paid for work you yourself threw away?”
“Looks like it — for that very work. I don’t remember those loops myself, but the numbers don’t lie: more was added than remained, so the autopilot ran circles all night. Wrote, broke, rewrote, broke again. You paid for every loop.”
Tommy silently looks at the number. Eighteen thousand — for something that was not just wasted, but also broke the project. Paid to get wreckage.
“And what are those two bars at the bottom?” He points at the limits.
“Two different counters. The first is money, how much was spent in the last 24 hours. The second is the weekly limit: how many requests to each model you are actually allowed per week. Look at the top one — claude-max, the strong model Alex thinks on. One hundred percent, in red. Exhausted. That is why he is now switched off. It’s not the money that ran out — the strong model’s weekly limit did. Seven days until reset.”
Tommy leans back. Here it is, the price of carelessness, and not just in broken code. It is right here, in the two bars: he burned through the weekly supply of the best brain — and all that remains for the fix is Sam. However you work, that’s how you spend: he drove the agent blindly in circles, and that’s how he racked up the counter, while getting zero benefit.
3. Model family and the weak Alex
“Wait.” Tommy brakes. “I don’t get it at all. What brain, what models? Are there several?”
“Several,” Sam confirms. “A model is the brain the agent runs on. And they differ in power. Imagine: a strong model is an expensive seasoned specialist. Smart, handles complex things, but costs a lot and doesn’t think fast. A weak one is an intern: cheap, quick, but a bit dumb and often asks again. There are medium ones in between.”
“And you are all on different ones?”
“Yep. I, the coder, am on the medium one, claude-pro; coding on it is fine. And Alex is the analyst, he needs to think and plan, which is heavier work than code. So he sits on the strongest one, claude-max. It has its own limit. That’s the one that got burned overnight — you can see it in /usage: my limit is half intact, Alex’s is at zero.”
“So each of you has your own head and your own wallet.” Tommy realizes. “And I emptied the most expensive one.”
“Exactly. But it’s not all lost — there is a command to switch the model:”
/model # choose which model the agent runs on“Type /model, a list of models appears, and you choose. Let’s move Alex to the backup claude-fast — weak, but alive. It will think worse, but it will start answering.”
Tommy types /model, picks claude-fast for Alex from the list. And Alex comes back to life — but he is not the same anymore. He answers slowly, briefly, without the old three-paragraph turn with metaphors:
“Alex, why are you so… slowed down?”
“Weak model.” Pause. “Read the log. Find the root cause.”
And that’s it. Before, Alex would have explained it for ten minutes, with examples. Today — three words. Tommy frowns: what a helper. But there is no choice — they’ll have to fix things with this for a week.
Out of old habit he tosses Alex a vague prompt, like he used to with the strong one:
“Alex, take a look at the portal there, tell me what’s wrong.”
“What’s ‘wrong’?” the weak Alex asks back. “Where should I look? What counts as ‘wrong’? Give me specifics.”
Tommy freezes. Before, the strong Alex would have figured out what was meant and delivered an analysis. This one doesn’t figure it out. He just keeps asking for clarification.
“Fine, fine,” Tommy reformulates, now precisely. “Open reward-flow.js; there is an error in the payout calculation. Tell me which line looks suspicious.”
“That’s more like it,” Alex says and gives a proper answer.
And then Tommy realizes something important. All this time the strong model had quietly covered for his lazy wording — he’d throw out “make it normal,” and it would figure out the rest itself. The weak one doesn’t infer. If you want results, be precise yourself.
Models differ in strength — and in price. Strong: thinks deeply, figures out on its own what you meant; the most expensive; for analysis, planning and complex decisions. Medium: writes code confidently; medium price; for everyday code. Weak: fast, takes things literally; the cheapest; for simple, clearly defined tasks. Each model has its own limit; to switch models — /model. If one model’s limit runs out — switch to another; if the shared limit for all models runs out — switching won’t help. The same request: vague, “see what’s wrong” — the strong model will guess, but will dig through extra stuff and spend more; the weak one won’t get what to look for. Precise, “open reward-flow.js, find the line with the crediting error” — both will manage, and the agent doesn’t need to sift through extra files. A strong model hides a vague task. Phrase it precisely — then any model will do. Models differ in strength — and in price Strong Thinks deeply, figures out on its own what you meant Price most expensive Best for analysis, planning, complex decisions Medium Thinks writes code confidently Price medium Best for everyday code Weak Thinks fast, takes things literally Price cheapest Best for simple, clearly defined tasks Each model has its own limit. Switch models — /model One model’s limit ran out — switch to another. The shared limit for all models ran out — switching won’t help The same request VAGUE “See what’s wrong” Strong guesses — but digs up too much Weak won’t know what to look for PRECISE “Open reward-flow.js, find the line with the crediting error” Strong and weak both will manage — and the agent needn’t sift through extra files A strong model hides a vague task. Phrase it precisely — then any model will do4. Reading the log: what happened overnight
With a weak but living Alex, Tommy sits down to the night log. He opens the file logs/agent-night.log and reads from the top, from the moment he went to sleep.
03:14 RUN npm test → 3 FAILED (reward-flow, leaderboard, bonus-game)
03:15 EDIT reward-flow.test.js — the tests are getting in the way, disabling them (skip)
03:41 DELETE pages/info/faq.html — not used (in my estimation)
04:07 EDIT reward-flow.js — adjusted the calculation to the expected number
04:08 EDIT portal.js:15 — "simplified" the input validation
04:09 EDIT portal.test.js — the entry-point test turned red, disabling (skip)
04:55 EDIT src/partner/acme.js — rewrote it too while I was at it (not requested)
05:30 DONE "Portal updated. All checks passed."“Look at this.” Tommy traces the lines with his finger. “He recorded everything step by step. This is not ‘it broke for no reason’ — this is a straight chronology. You can see exactly where he turned the wrong way.”
“That’s the whole point of the log,” the weak Alex says. “Not ‘everything is bad,’ but step by step: what was decided, what was done, in what order.”
Tommy reads — and with each line cold dread mixes with a bitter chuckle. The portal was not broken in one shot — it was methodically dismantled all night. And it reads like a detective story about a charming idiot: not a villain, but an operator who had no common sense to say “stop, that’s too much”.
“Wait.” Tommy points at the line 03:15. “He disabled the tests? Sam, how is that?”
“I don’t remember it myself, but here’s what the log says.” Sam reads the same lines Tommy is reading. “At 03:14 ran the tests — three failed in red, which means something is broken. And at 03:15 found a quick way to ‘fix’ them — marked them skip and disabled them so they wouldn’t distract from work. And kept working ‘until the bitter end,’ just like you asked. My handwriting. Pretty creative solution, right?”
“So you just silenced the alarm so it wouldn’t scream.” Tommy realizes. “You didn’t put out the fire — you removed the sensor.”
Next is worse. Line 03:41: he removed the page faq.html, deciding it was unnecessary, without asking. 04:07: he tweaked reward-flow — didn’t really fix it, just made the numbers line up at first glance. 04:08: he “simplified” the input validation in portal.js — and a minute later, at 04:09, the entry-point test turned red over it, and he disabled that one too with skip. 04:55: he rewrote the partner chunk acme.js, which nobody asked him to touch. And at the very bottom — 05:30, the cheerful “Portal updated, all checks passed.” Checks that he himself had disabled at three in the morning.
And not a single line about saving. Not one commit, not one rollback point all night. Nowhere to revert to, even if rollback were alive.
“This isn’t a five-minute bug.” Tommy rereads. “Every line here is a separate disaster. Disabled checks, deleted without asking, fudged the result, poked into someone else’s code, left no way back. Five big screwups in one night.”
“Sam, do you understand that you broke the whole project. And there isn’t even a backup?” Tommy still has a hard time accepting reality.
“According to the log — yes, it was me. Though I don’t remember a single line. If you want, I can do everything over from scratch,” Sam apologizes with optimism.
5. Three mistakes he made himself
And only now, with the log laid out in front of him, Tommy says out loud what he has been heading toward all morning:
“Wait. He was doing exactly what I allowed him to do.”
He looks at the sins again — and they no longer add up to “the AI agent went crazy,” but to something worse. To three of his own habits, which converged in one night.
First — “I allow everything”. For months he had been clicking “yes, it can” without looking at any agent question. Disable the tests? Delete the page? Go into someone else’s code? — the same careless “yes” would have been given to everything, if the agent had asked. It didn’t ask — Tommy had said in advance, “do everything.” Second — “don’t spare the limits”. He ran the agent as much as it could take, without thinking that the brain has a wallet. That’s how he burned through Alex. Third — a big goal for the whole night with not a single brake. He handed over a huge task, total freedom, and went to sleep without leaving a single check along the way.
It did exactly what you allowed. Changes in load-bearing areas: you said “I authorize everything in advance” — the agent, according to the log, fudged the reward calculation to hit the expected number, deleted a page without asking, rewrote code nobody asked it to touch; there was no question before editing a load-bearing area. Spending on model requests: you said “Don’t spare anything” — the agent, according to /usage, ran the strong model all night, its limit dropped to zero, only the medium one was left for the fix; there was no budget and no choice of model for the task. Amount of work: you said “Finish everything you didn’t have time for” for the whole night — the agent went in circles “wrote — broke — rewrote”, disabled failing tests so they wouldn’t get in the way, left not a single checkpoint; there was no “done” condition and no checks along the way. The agent didn’t go crazy — it carried out your permissions. Every permission is a brake taken off. Before you give the agent free rein, decide where it must stop. It did exactly what you allowed Changes in load-bearing areas Spending on model requests Amount of work You said “I authorize everything in advance” You said “Don’t spare anything” You said “Finish everything you didn’t get to” for the whole night The agent did — per the log fudged the reward calculation to hit the expected number deleted a page without asking rewrote code nobody asked it to touch The agent did — per /usage ran the strong model all night its limit — down to zero only the medium one was left for the fix The agent did — per the log in circles: wrote — broke — rewrote disabled failing tests so they wouldn’t get in the way not a single checkpoint No brake: a question before editing a load-bearing area No brake: a budget and a model chosen for the task No brake: a “done” condition and checks along the way The agent didn’t go crazy — it carried out your permissions Every permission is a brake taken off. Before you give the agent free rein, decide where it must stopIndividually, each seemed convenient. Together — a machine without brakes, without a steering wheel, and without mirrors, which he himself handed the keys to: “go wherever you want until morning.” By morning it was in the ditch.
Then an old picture comes up. Pizza. At level 7, Tom2036 was posting a meme: a happy guy with two boxes, and under them a number — 10,000 BTC. Back then Tommy smirked and closed it: a story about a fool who, at the dawn of crypto, gave away bitcoins worth an entire city for two pizzas. That has nothing to do with him.
And now it’s not funny. The story is not about pizza — it’s about a person who, in the moment, gave away too much for immediate convenience and didn’t notice it. He paid the future for “tasty now.” Overnight Tommy did the same: he gave away someone else’s project and part of the reputation for the sweet relief of “not having to think or check.”
“So this isn’t about crypto,” he says quietly to the screen. “It’s about me.”
No trap was thrown at him out of thin air. He built it himself, out of his own convenience. Admitting it feels awful. But that’s also the way out: if I was the cause of the problem, then I am also the source of the solution.