Don't Let AI Coding Tools Eat Your Margin: A Vibe Developer's Dev-Side AI Bill Playbook

First, Be Clear: This Guide Is About Money You Spend

We previously published Burn Your Tokens Wisely (vibe-project-llm-inference-cost-guide). That one covers the product side: how many tokens your users burn per call once your product ships, and how you price to cover it. A separate guide covered pricing paywalls — that's about money you collect from users.

This guide runs in the opposite direction. It's about the dev side: the money you burn every day writing code with Cursor, Claude Code, Copilot, and Codex. The bill shifts from "your users" to "you", and the optimization playbook changes from "caching, batching, model downgrades" to "pick the right tier, kill the money-burning switches, audit weekly". Read both and your AI spend is fully covered.

The headline first: as of October 2026, none of these four still sells "one flat fee, use all you want". Cursor overhauled its pricing in October (the old Pro $20/month is history), Copilot moved entirely to credits, Codex rides on your ChatGPT plan, and Claude folded Claude Code into one shared usage pool. If you're still buying on last year's mental model, the extra you pay each month would cover another cloud server.

Chapter 1: Billing Models, Demystified — Subscription vs Credits vs Per-Token

Four tools, three ways of taking your money. Know what you're paying for before any saving trick makes sense.

Subscriptions: you're buying a usage pool

Cursor: after SpaceX acquired Cursor's parent Anysphere in an all-stock deal in August 2026 (about $60 billion, Cursor folded into SpaceXAI), the official pricing page (cursor.com/pricing, verified 2026-10-23) now shows brand-new tiers: Free $0, Plus $8/month, Premium $30/month, Super $100/month, Ultra $200/month. Note Plus only gets Grok models; Premium starts at 4× Plus usage, Super 15×, Ultra 50×. The official FAQ's own words: Premium for new AI users, Super for daily agent users, Ultra for power users. Allowances refresh weekly, not monthly — one heavy day won't wipe out your month, but you'll face the cap every week. When you run out, top up or wait for the refresh.

Claude (including Claude Code): Claude Code has no standalone subscription — it's included in every paid Claude plan and shares one usage pool with web, desktop, and mobile. Pro is $20/month ($17/month billed annually, $200 up front), Max comes in 5× and 20× tiers (page shows "From $100", including $100–$200/month in API credits). Usage settles on a rolling five-hour window, with weekly caps stacked on top for paid plans. When you hit the wall you have three options: wait for the reset, upgrade, or turn on usage credits to keep going at standard API rates — check where you stand anytime in Settings > Usage.

Codex: no standalone subscription; it follows your ChatGPT plan: Free $0, Go $8/month, Plus $20/month, Pro at $100/$200/$500. Plus is the 1× baseline (five-hour rolling window); Pro $100 gets 5× Plus, Pro $200 gets 10× Plus (from October 30, 2026, existing users drop from 20× to 10× too), Pro $500 gets 25× Plus plus Astra Ultrafast. When Plus runs dry you can buy ChatGPT credits to keep going — note these are ChatGPT credits, not OpenAI API credits; two separate ledgers. Check usage in ChatGPT's Settings → Usage or Codex's Usage & Billing, or type /status in the CLI.

Credits: 1 credit = $0.01

Copilot abandoned per-request billing in June 2026 and moved to GitHub AI Credits: 1 credit = $0.01. Pro $10/month includes 1,500 credits (1,000 base + 500 flex), Pro+ $39/month includes 7,000, Max $100/month includes 20,000. The Free tier gets 2,000 completions a month plus a small credit allowance. The key rule: code completions and next-edit suggestions cost zero credits and are unlimited on paid plans; what burns credits is Chat, agent mode, the CLI, cloud agents, and code review. When credits run out, wait for the reset at midnight UTC on the first of the month, or set a dollar budget ($10 = 1,000 credits) and keep working, with alerts at 75%, 90%, and 100%. GitHub's docs add a small perk: paid plans get a 10% discount on model costs with auto model selection.

Per-token: the API and BYOK math

All three leave a metered back door: Anthropic says heavy coders can switch to pay-as-you-go API credits through a Console account; Codex with your own API key skips plan limits and bills per token; Cursor's Premium tier and above can use third-party models billed separately at API list price, outside the plan's usage pool, with a spending cap you can set. Per-token fits "spiky" usage — light most days, crushing it for a day or two a month, where a flat subscription would be waste.

Tool	Billing model	Entry tier	Main tier	Heavy tier	When you run out
Cursor	Subscription (usage pool, weekly refresh)	Plus $8/mo (Grok models only)	Premium $30/mo (4× usage)	Super $100 / Ultra $200 (15×/50×)	Top up or wait; third-party models billed separately at API price
Claude Code	Subscription (shared pool with Claude, 5-hour window)	Pro $20/mo	Pro $20/mo	Max 5×/20× (from $100)	Wait / upgrade / usage credits at API rates
Copilot	Credits (1 credit = $0.01, monthly reset)	Free (2,000 completions)	Pro $10/mo (1,500 credits)	Pro+ $39 (7,000) / Max $100 (20,000)	Set a dollar budget, alerts at 75/90/100%
Codex	Subscription (tied to ChatGPT plan, 5-hour window)	Plus $20/mo (1×)	Plus $20/mo	Pro $100 (5×) / $200 (10×) / $500 (25×)	Buy ChatGPT credits; or API key per-token

The selection logic in one line: stable usage → subscription; spiky usage → credits/per-token; heavy stable usage → a high subscription tier with a cap as circuit breaker.

Chapter 2: Do the Math — Monthly Bills for Three Typical Indie Devs

Tier tables are still abstract. Let's run three people's numbers (all at official monthly prices).

Alex, light user. Mostly Copilot Free completions, occasionally fires up Cursor Plus ($8/month) for a small agent task. Monthly spend: $8. That's $96 a year — less than one decent team dinner.

Ken, daily agent user. Claude Pro ($20/month, Claude Code fully included) as the main tool, plus Copilot Pro ($10/month) as the in-IDE sidekick. Monthly spend: $30. He did the math: Claude Pro's five-hour window occasionally walls him in the afternoon, and a $10 Copilot Pro backup is far cheaper than jumping to Max.

Liu, heavy user. Cursor Super ($100/month, 15× usage) running multiple agents inside the IDE, Claude Pro ($20/month) running long jobs in the terminal. Monthly spend: $120. Expensive, but his logic is clean: the two tools have distinct jobs (in-IDE vs terminal), neither replaces the other, and $120 buys the certainty of never queueing for a refresh.

See the pattern? Nobody buys four entry tiers. "One main tool + free tiers as backup" is the indie standard. Four $20 base subscriptions total $80/month and perform worse than one $30 main subscription plus three free tiers. Concentrating budget means spending on the tool you have open eight hours a day.

One more detail hidden in the numbers: Copilot credits carry "leverage". Pro pays $10 for 1,500 credits (face value $15) — 1.5× leverage; Max pays $100 for 20,000 credits (face value $200) — 2× leverage. The higher the tier, the more real usage each dollar buys. So "keep topping up with budgets when you run dry" is the worst posture — chronic overage users save money by upgrading instead.

Chapter 3: Tier Selection Decision Table — Pick Your Seat, Don't Pay for Capacity You'll Never Use

Check the decision chart first, then the table. The core principle: set intensity first, budget second. Buying the entry tier of all four tools is the most common waste among indie developers — concentrate that budget on one main tool instead.

Profile	Typical behavior	Recommended tier	Monthly budget
Light Tab user	Mostly completions, occasional questions, no agents	Copilot Free ($0) or Cursor Plus ($8/month)	$0–10
Daily agent user	Uses agents daily to change code and run tasks, mostly single-threaded	Claude Pro ($20/mo) / Cursor Premium ($30/mo) / Codex Plus ($20/mo) / Copilot Pro ($10/mo)	$20–30
Heavy multi-agent user	Multiple agents in parallel, cloud agents running, PR reviews	Cursor Super ($100/mo) / Claude Max / Copilot Max ($100/mo) / Codex Pro (from $200)	$100+

Two iron rules for upgrades. First, if you hit the usage ceiling two weeks in a row, move up one tier — don't limp along on top-ups and budgets; scattered renewals usually cost more per month than the upgrade. Second, downgrading is not shameful: when the project enters maintenance and agents sit idle, drop back down. Subscriptions bill monthly and downgrade anytime; the money saved is certain.

Chapter 4: Three Money-Burning Traps and Their Circuit Breakers

Trap 1: flagship models on by default

This is the most expensive default setting. All four vendors' flagship models burn several to ten times faster than their light models: on Codex Plus, a five-hour window fits roughly 5–45 messages at GPT-6 Astra class but 350–3,000 at GPT-6 Luna class — same subscription, wrong model choice, an order of magnitude less real work (estimated ranges from OpenAI's help pages). In the new Cursor, third-party models don't even draw from your plan pool — they're billed separately at API list price while you assume you're inside the plan. In Copilot, frontier models eat far more credits per round than light ones. In Claude Code, flipping on Opus visibly drains the pool.

Circuit breaker: set your default model to the middle tier (Sonnet class) and only switch to flagship manually for genuinely hard problems; set a spending cap for third-party models in Cursor; keep Copilot's auto model selection on for the 10% discount.

Two time-sensitive notes. First, Codex Pro $200 users, watch October 30: OpenAI emailed that from October 30, included Codex/Work usage on Pro $200 drops from 20× to 10× Plus at the same price. Existing users keep old limits through October 29 and get a one-time grant of 62,500 credits (valued by OpenAI at $2,500, expiring December 31). If you're on Pro $200, decide this week: drop to Pro $100, or burn through the heavy work before the credits expire. Second, Cursor veterans, check your migration: the old Pro $20/month is history — open Settings and confirm which tier you're actually on and how big the pool is, instead of paying new prices on old assumptions.

Trap 2: unbounded context growth

Agents resend the whole conversation history every round. In a 200k-token session, by round 50 most of your input bill is re-paying for code you've already seen. Sneakier is the "might as well" habit: dragging the entire repo into context, letting the agent read directories it never needed.

Circuit breaker: start fresh sessions regularly (Claude Code's compact, every tool's clear, exist for a reason); give the agent a slimming instruction — "only read files you need, don't scan the whole repo"; put project background in CLAUDE.md / rules files so it isn't re-explained every round. A template opener you can copy: "First list the files you plan to read and get my confirmation; don't recursively scan the repo; report each subtask in one sentence, don't paste large code blocks." Three sentences can cut a round's input in half.

Trap 3: cloud agents idling

Codex cloud, Cursor's cloud agents & automations, and Copilot's cloud agent share one risk that isn't price — it's forgetting they're running. A cloud task left hanging Friday night can burn half a month's budget by Monday morning, retrying a bug you already fixed by hand.

Circuit breaker: give cloud tasks explicit acceptance criteria and timeouts; check the background task list before you walk away from the machine; note that Cursor's cloud agents only exist on Premium and above — Plus users are naturally immune, and sometimes the lower tier is the money-saving feature.

Chapter 5: Four Cost-Cutting Moves

Move 1: master prompt caching

This is the strongest discount in Anthropic's published API pricing, and Claude Code uses it automatically: cache reads cost 0.1× the input price (90% off), cache writes cost 1.25× (5-minute TTL) or 2× (1-hour TTL). System prompts, tool definitions, and CLAUDE.md resent in the same session cost 0.1× after the first pass. The math: a 5,000-token system prompt requested 100 times an hour. Uncached: 100 × full price = 100 units of input spend. Cached: 1 write at 1.25× + 99 reads at 0.1× = 11.15 units — about 89% saved. Your only job: don't break prefix matching — timestamps, random IDs, or ever-changing user identifiers in the prompt invalidate the cache and re-bill at full price. OpenAI has automatic prompt caching too (about 50% off, no configuration), same logic.

Move 2: let Auto mode route

Cursor has Auto mode; Copilot has auto model selection (with the 10% paid-plan discount). The principle: let the tool decide what's light work and what's heavy. Writing comments, editing copy, fixing lint — none of it deserves a flagship model. Specify models manually only twice: when you know the task is hard, or when you know it's trivial (then pick the cheapest).

Move 3: local models as the backstop

Completions and simple Q&A can run on local models (Ollama-style) at zero marginal cost. Be honest about the tradeoff: local small models handle boilerplate fine; complex refactors and cross-file reasoning are still cloud models' job. The practical setup is layered — IDE completions on local, agent tasks on the cloud subscription. A light user finding Copilot Free's monthly allowance (2,000 completions on Free; unlimited only on paid plans) too tight is better off with local models + pay-as-you-go than jumping straight to Pro+ at $39.

Move 4: the BYOK tradeoff math

Bring Your Own Key suits one profile: spiky usage with intense peaks. Light most days (say $0.50/day of API value) but crushing it 12 hours a day two or three days a month ($8/day): metered API costs about $50/month; a high subscription tier prepares 30 days of capacity for those two or three days — waste. Codex with an API key skipping plan limits, Claude via Console pay-as-you-go, Cursor third-party models at API list price all follow this logic. Conversely, if you run agents 8 hours daily, buy the high subscription — the capped price will beat metered. The formula is simple: average monthly usage × API unit price vs subscription price, pick the smaller, recompute quarterly. A concrete mix: 20 light days plus 5 crunch days runs ~$50 metered; Claude Pro $20 plus ~$30 of usage-credit top-ups on crunch days lands in the same place — subscription + metered hybrid is often optimal. BYOK isn't either/or; it's the subscription's overage cushion.

Chapter 6: The 15-Minute Weekly Bill Audit SOP

Saving moves are one-offs; audits compound. Every Friday before you log off, 15 minutes, four steps, no exceptions:

• Step 1 (5 min): check four places. Cursor: remaining usage in Settings; Claude: Settings > Usage; Copilot: the Copilot settings page for usage and reset date; Codex: ChatGPT Settings → Usage or /status in the CLI. Write down the four numbers.
• Step 2 (3 min): compare with last week. Which tool jumped 50%+? Why — a crunch week, or a cloud task you forgot to kill?
• Step 3 (4 min): hunt anomalies. Did any Copilot budget alert fire at 75%/90%? Any separate third-party-model billing in Cursor? Any ChatGPT credits bought for Codex? Any usage credits opened on Claude?
• Step 4 (3 min): take one action. Exactly one: upgrade, downgrade, kill a cloud task, change a default model, or set a cap. Check the effect next week. An audit that produces no action is no audit.

Log the four numbers in a table for 8 weeks and you'll know, for the first time, what share of your income "AI coding" really takes. For an indie developer that's your R&D expense ratio — lose control of it and profit is paper wealth. The template is simple: columns for date, Cursor remaining/total, Claude five-hour window status, Copilot credits remaining, Codex window status, and this week's action. After 8 weeks you'll see the tide — crunch weeks vs quiet weeks can differ 3×, and tiers should follow the tide instead of sitting fixed all year.

Appendix: Five Questions Everyone Asks

Q1: I have Claude Pro — do I still need Copilot Pro?
It depends on the split. Claude Pro shines at long agent jobs in the terminal; Copilot Pro shines at always-on completions and light Q&A in the IDE. If 90% of your time is terminal, one Claude Pro is enough; if it's half and half, $10 Copilot Pro is cheap insurance. The anti-pattern: buying both at high tiers and using one of them under 20% — kill it.

Q2: Is Cursor Plus $8's "Grok models only" enough?
Honest answer: fine for small features and bug fixes; not enough for cross-file refactors or heavy agent work. Plus is positioned as the on-ramp to the new Cursor — the official FAQ recommends it to "social creators with limited AI usage", not developers. Developers should either trial on Free or start at Premium.

Q3: How far does the free tier really go?
Copilot Free's 2,000 monthly completions plus a small credit allowance can carry a student writing pure code for a month; one afternoon of agent-driven feature work can burn the credits. The right use of free tiers is trial and backstop, not main driver. Claude's free tier excludes Claude Code, Codex's free tier is limited and metered — to do real work, budget at least one $10–20 paid tier.

Q4: Is annual billing worth it?
On pure numbers, yes: Claude Pro annual is $17/month, saving $36 a year. But AI coding tools are 2026's fastest-moving category — Cursor just repriced three months ago, Codex just moved its Pro tier last month. Locking in a year risks watching a better tool or cheaper tier appear while you can't leave. Rule of thumb: annual is fine for a main tool you've used steadily for 3+ months; anything new stays monthly.

Q5: Any discounts for students or open-source authors?
Yes. GitHub's official line: verified students get Copilot free, and verified teachers plus maintainers of popular open-source projects can apply for free Copilot Pro. It's the only legitimate zero-cost path to a paid tier in the whole market — claim it if you qualify.

Closing

The truth about dev-side AI bills in one line: you're not paying for "intelligence", you're paying for wasted intelligence — flagship models fixing punctuation, cloud agents idling overnight, weekly wall-hits papered over with top-ups. Right tier, right default model, 15 minutes a week of attention, and most indie developers can hold this cost at $20–30/month. What's saved is your real profit. And the best part of this method compounds: every dollar you save for yourself today becomes pricing confidence for your product tomorrow.