The Bill That Wasn’t Supposed to Be That Big

If your last AI coding assistant invoice looked stranger than expected, you are not alone. Most indie developers signed up for a flat monthly plan and discovered later that chat sessions, agent runs, and premium model requests were quietly drawing down a separate credit or token pool. The sticker price is still the entry fee. The real monthly cost is set by how heavily you drive the agent.

This guide walks through how the major assistants actually meter usage in 2026, how to set per-developer limits before surprises land, where local models can replace paid credits, and how to audit an existing subscription without losing a week to spreadsheets.

Seat-Based vs Usage-Based: What Changed

Two years ago, almost every coding assistant charged a flat monthly fee and advertised “unlimited” completions or a generous fixed request count. That model mostly disappeared.

Today’s assistants tend to split billing into two layers:

  • Seat subscription — what you pay each month for the right to use the editor or extension. This part is predictable.
  • Usage pool — a bucket of credits, tokens, or compute units that drains when you run chat, agents, or premium models. This part is the wildcard.

Inline completions (the grey text that pops up as you type) generally stay free or cheap across all the major tools. The expensive part is anything agentic: multi-file refactors, long chat threads, running the most powerful model on a large codebase. When that bucket empties, you either stop working, wait for the pool to refill, or get billed at API rates for overage.

If you only use completions, the seat price is close to your real cost. If you lean on agents or switch to frontier models for hard problems, expect the invoice to climb.

How the Major Tools Meter Usage Right Now

Exact numbers shift often, so treat the table below as a snapshot, not a contract.

Tool Entry paid plan Free tier How usage is metered
GitHub Copilot Pro, around $10/mo 2,000 completions + 50 chat requests/month Token-based AI Credits on paid plans; completions stay free, chat and agents draw down credits
Cursor Pro, around $20/mo Limited agent requests, no card required Monthly usage pools, proprietary models are generous, third-party models billed at API rates, overage billed after the month
Devin Desktop (formerly Windsurf) Pro, around $20/mo Light daily/weekly quota Quota that refreshes daily and weekly; overage charged at API pricing
Claude Code Through Claude Pro, around $20/mo No free coding tier Shared 5-hour and weekly limits with Claude chat, or API pay-per-token

A few details worth flagging:

  • Copilot and Cursor both offer real free tiers. Claude Code requires a paid Claude plan.
  • Cursor’s overage is billed in arrears, which means you see the damage on next month’s invoice, not at the moment you exceed it.
  • Several vendors currently run promotional credit boosts that expire later in 2026. When those expire, teams whose usage has not changed will see their true baseline for the first time.

Set a Per-Developer Limit Before You Need One

The cheapest cost-control move is to set a ceiling while things are calm. Three practical steps:

1. Pick a model tier per developer, not per project. Front-tier models (the most expensive options) handle ambiguous planning and large refactors well. Mid-tier models are usually fine for routine edits, tests, and explanations. Decide who actually needs the expensive tier and lock the rest to mid-tier.

2. Turn on spend alerts. Most assistants surface a usage dashboard in account settings. Set an email or in-app alert at, say, 50% and 80% of the monthly pool so you can react before overage kicks in.

3. Use the free tier for low-stakes work. Documentation snippets, throwaway scripts, and learning experiments rarely need a premium model. A free Cursor or Copilot account covers most of that.

If your tool does not expose per-seat limits, an older but reliable workaround is to issue one account per developer and have each person set their own alert. The administrative overhead is small and the savings are real.

When a Local Model Is the Right Choice

Local LLMs have crossed a useful threshold. For routine tasks, a well-tuned local model running on your own laptop or a small box can replace paid credits without a noticeable quality drop.

Local models make sense when the work is:

  • Boilerplate code, config files, or repetitive refactors
  • Test scaffolding and unit test generation
  • Renaming, formatting, and import cleanup
  • Explaining small functions or short error messages

Local models are a poor fit for tasks that need a very large context window, deep multi-file reasoning, or the strongest reasoning model available. For those, you still want a paid frontier model.

A reasonable setup is to keep a paid assistant for hard problems and route everything else through a local model through an open-source client such as Continue, Aider, or OpenCode. You pay nothing per request and your code never leaves your machine.

Detect Silent Overage Before the Invoice Arrives

Most bill shock comes from one of three places: agent runs left running overnight, a teammate experimenting with a frontier model, or a misconfigured setting that defaults to the most expensive tier.

A short monthly audit catches all three. Once a month, block 30 minutes and run through this checklist:

  • Pull the usage dashboard for every assistant your team uses. Note the month-over-month change.
  • Sort users by spend. A single heavy user can dominate the bill.
  • Check model defaults. Confirm nobody’s editor is silently pointing at a premium model for routine completions.
  • Review active sessions. Cancel any agent jobs still running from days ago.
  • Reconcile against the invoice. If the dashboard number and the invoice number diverge by more than 10%, investigate.

This habit pays for itself the first time you catch a runaway agent before it runs up a four-digit bill.

A Simple Cost-Control Playbook

If you only do five things, do these:

  1. Match the model tier to the task, not to the developer’s job title.
  2. Set spend alerts at 50% and 80% of the monthly pool.
  3. Route routine work through local models or free tiers.
  4. Audit usage once a month against the invoice.
  5. When a promotional credit boost expires, expect a step-change in cost and adjust before it happens.

FAQ

Is it cheaper to pay per developer or per token? For heavy agent users, seat plus token is often the cheapest path because the seat includes a baseline pool. For light users who only use completions, a flat seat plan is usually enough.

Can I set a hard cap that stops a developer from going over? Some tools expose hard caps at the organization level. Others only surface alerts. Where hard caps do not exist, the next best option is per-seat accounts with alerts.

Do local models really replace paid assistants? For routine work, often yes. For hard architectural reasoning and large-context tasks, the paid frontier models still win.

How often should I re-check pricing? At least once per quarter. This category rewrites its pricing pages often.

Sources