On June 1, GitHub Copilot moved to a credit-and-usage model, and r/GithubCopilot lit up for the rest of the month. The top thread — "Pay the same, get anxiety for free" — broke a thousand upvotes. Others: "Love the new token system" (from someone who'd burned 25% of their monthly allotment on day one), "Cancel your Copilot subscription today," and enterprises quietly disabling Opus over the change.

Copilot isn't an outlier. Cursor went through its own pricing convulsion. The whole category is converging on the same model. If you want to know whether to be angry, switch tools, or just adapt, it helps to understand why this happened — because the reason is structural, and it tells you exactly how to keep your bill under control.

Why flat subscriptions couldn't survive

The old deal was $10–20/month, unlimited-ish. It worked when "AI coding" meant autocomplete: cheap, bounded suggestions where everyone's usage looked roughly the same. The vendor could average across users and come out ahead.

Agents broke that math in two ways.

The cost moved from fixed to variable. Every agent run is a stack of model calls against a provider that charges per token. A flat monthly fee in front of a per-token cost only works if usage is predictable. It isn't.

Usage stopped being uniform. With autocomplete, a heavy user cost slightly more than a light one. With agents, a power user running multi-step tasks against frontier models all day can cost orders of magnitude more than a casual user — and can easily cost the vendor more than they pay. Under a flat fee, the light users subsidize the heavy ones, and the heavy ones have every incentive to run the most expensive model on every task because it's "free." That's not a pricing wrinkle; it's a money furnace.

Usage-based billing is the vendors pushing the variable cost back onto the people generating it. Pay for the tokens you actually burn. Painful, but not arbitrary.

Why it feels so much worse

Most of the anger isn't really about the average bill — it's about variance. A flat subscription is a fixed, forgettable line item. Usage billing turns your tooling into a meter that ticks while you work, and now part of your attention is spent watching it instead of coding. "Pay the same, get anxiety for free" nails it: even when the total is similar, the unpredictability is a real, ongoing tax on focus.

So the goal isn't just "spend less." It's to make the bill predictable again — to get the meter out of your head.

How to keep a usage bill under control

A few habits do most of the work:

Match the model to the task. The single biggest lever. Frontier models are worth it for genuinely hard problems; most edits, renames, explanations, and boilerplate don't need them. Defaulting every task to the most expensive model is where bills explode.
Mind your context window. You're billed on tokens in and out, and a bloated context — whole repos stuffed into every prompt — is pure waste. Tighter, relevant context is both cheaper and usually produces better answers.
Lean on local models for the routine 80%. Anything you'd be comfortable running offline — quick refactors, test scaffolding, reading a stack trace — can run on a local model at zero marginal cost, leaving your paid budget for the hard 20%.
Set and watch a budget. Most platforms expose spend limits and dashboards. A hard cap plus an alert converts "surprise invoice" into "expected number." Predictability beats raw frugality.
Don't reflexively cancel — re-fit. The cancel threads are loud, but for a lot of people the usage model is actually cheaper once they stop running Opus on a one-line change. Measure your real usage for a month before reacting.

Where 1DevTool fits

The reason model choice and local routing keep coming up is that they're the two biggest levers on a usage bill — and they're exactly what a model-agnostic workspace is built to give you. 1DevTool lets you route routine work to a local model and reserve cloud frontier calls for the tasks that need them, from inside the same workspace your code already lives in. Instead of one expensive default applied to everything, you get to spend deliberately — which is the whole game once the meter is running.

For the deeper privacy angle on running work locally, see our piece on data boundaries for AI coding — the same local-first habit that protects your code also flattens your bill.

The bottom line

Usage-based billing isn't a cash grab so much as the inevitable result of agents turning a fixed cost into a wildly variable one. It's not going away, and tool-hopping to escape it mostly just resets the clock. The durable move is to treat model choice as a budget decision: run the cheap, local path for the routine majority, pay for frontier power on the hard minority, and put a cap and an alert on the rest. Do that and the meter goes quiet — which was always the real thing you were paying for.