Metered agents charge vibe coders twice for the work they don't codify

I spent an evening this week walking my own fleet looking for the places it pays twice. Not because the work was broken. Because in five days the meter turns on, and I wanted to find the repeat charges before the bill did.

Here is the category move, stated vendor-free so it survives any one company's pricing email. The agent layer, the headless runs, the CI actions, the loops that fire while you sleep, is moving off the flat subscription bucket and onto a separate metered pool priced like raw compute. Interactive typing in a chat window stays where it was. The thing that changes is the part of vibe coding that runs without a human at the keyboard, which for anyone orchestrating a fleet is most of it. A second platform repackaged its own agent tier in the same window. This is a category shift with a date attached, not one vendor's bad week.

I have written twice already about what that meter does. The first time I argued you should instrument what the fleet costs per task before the cutover teaches you the shape of it. The second time I argued that keeping the labs swappable turns a pricing change into someone else's emergency instead of yours. Both still hold. Measure it, stay portable. This post is the third lever, and it points inward, at your own orchestration rather than at the vendor.

name the failure surface before you reach for the fix

The discipline I keep coming back to is to name the expensive failure mode first, in plain words, before building anything around it. Build the failure surface before the happy path. So here is the failure mode metered billing exposes, named: a fleet that re-derives the same work on every run because nothing wrote that work down.

Under flat rate this is invisible. A run that re-reads the whole vibe-coded codebase to relearn the conventions, a researcher pass that re-discovers the same three project facts it discovered yesterday, a builder that regenerates against vibes and rederives the contract every time because the contract lives nowhere durable. None of that costs anything you can see when the marginal run reads as free. The moment the meter starts, every one of those repeats is a line item. You are not paying for the work. You are paying, over and over, for the work you already did and threw away.

the codification feedback loop, in practice

The cheapest version of this story is the one that taught me to look for it. I run a researcher role in the fleet, the agent that goes and finds the unfamiliar parts of a job. Early on it was quietly re-deriving the same project context on nearly every task: the same conventions, the same naming rules, the same "here is how this codebase wants things done." Move one was the diagnostic, just noticing the repeat, that the agent was spending real tokens rediscovering facts that had not changed since yesterday. Move two, the same day, was the inheritance: I wrote the context down once, into the spec and the durable notes the fleet reads at the top of a run, so the next run inherits it instead of rebuilding it from scratch.

That is the whole loop. Diagnose a thing the fleet keeps re-deriving, codify it once, and every run after that reads the codified version for the price of a read instead of paying full freight to derive it again. Spec-first discipline gets sold as a quality move, a way to stop the agent drifting off-contract, and it is that. But the same written contract that keeps a build honest is also the thing that stops your fleet buying the same answer twice. Codification is a quality habit that turns out to have a meter reading attached.

The failure mode to watch for is the fleet that feels productive precisely because it is busy re-deriving. Lots of motion, lots of runs, lots of the agent confidently rebuilding context it had last week, and at flat rate that looks like throughput. Metered, it reads as a fleet that never learned, paying tuition on the same lesson every morning. Busy and cheap are not the same claim, and the meter is what settles the difference.

the move is unglamorous

Find the work your fleet repeats and has nothing to inherit from. The conventions it relearns, the context it re-reads, the decisions it re-makes because they were never captured. Write that down once, where the next run will read it. Specify the job instead of re-deriving the job. Let the expensive loops fire against codified context, not against a blank slate they have to repopulate every time. The point is not to run the fleet less. It is to stop paying full price for answers you already bought.

None of this is glamorous and none of it is new. The deadline is the only new part. Codifying what the agents keep re-deriving was always good practice for vibe coders who ship past the toy stage; in five days it also stops being free not to.

If you are formalizing your AI orchestration and you can feel the fleet re-deriving work it should be inheriting, that is exactly the kind of thing worth speccing on purpose before the meter starts counting it. Work with VibeKoded if you want a sparring partner on finding the repeat charges in your own setup and codifying them away.