Tokens vs credits: what you are actually paying for when you vibe code

What it actually is

Two different units hide under the word “usage.” Tokens are the real unit AI companies bill against, roughly 4 characters of text per token, so “fix the login bug” comes out to about 5 tokens. Every prompt you send, every line of code the model writes back, and the entire conversation history resent behind the scenes all get counted in tokens. Providers also charge differently for tokens going in versus tokens coming out. On Claude models right now, generating a token costs roughly five times what reading one costs, because writing new text takes more work than processing existing text.

Credits are what most vibe-coding tools put in front of you instead of raw token math. Cursor, Lovable, Replit, and Bolt buy tokens wholesale from Anthropic or OpenAI, then resell you a proprietary unit (a “credit,” a “fast request,” a “message”) mapped to some bundle of tokens the company sets internally. That exchange rate isn’t fixed: a small CSS tweak might cost one credit, a multi-file feature request might cost ten, and the company can quietly change the ratio in a pricing update.

Think of a prepaid transit card. The transit authority tracks the real cost in cents per mile. You just see “12 rides left” on the card, at whatever rate the card issuer set.

Why your AI just did this

Your coding agent has no memory between requests. The model itself is stateless. Every time you send a message in a Claude Code session or a Cursor chat, the tool resends the whole conversation so far: your original request, every file it read, every edit it made, every “yes, go ahead” you typed. By turn 40 of a long debugging session, a one-line follow-up like “now fix the tests” can drag thousands of tokens of resent history along with it.

That’s also why pasting a full 2,000-line file into chat is expensive: the file becomes part of every future turn’s input until it ages out of context or you clear the conversation. On models with extended reasoning, the AI also generates invisible “thinking” tokens before it writes your visible answer. Those get billed as output too, even though you never read them.

When you’ll run into it

• Cursor’s dashboard showing you’ve burned through your included monthly usage and moved into pay-as-you-go rates
• Lovable’s credit counter dropping after a single “make the button bigger” message
• Claude Code flagging a full context window, or prompting you to run /compact
• An API dashboard bill that jumps after an agent ran unattended overnight on a migration
• A blunt “you’ve run out of credits this month” message, or a 429 rate-limit error mid-session

What to check

• Confirm whether your tool bills token-for-token (pass-through API pricing) or its own credit/request unit. Read the actual pricing page, not just the tier names
• Check your usage dashboard for the input/output token split. Output is the expensive half, so long generated replies cost more than long pasted-in context
• Watch for context bloat in long sessions. Use /compact in Claude Code, or start a fresh chat in Cursor/Lovable, instead of letting history grow unbounded
• If you’re on a raw API key rather than a subscription, set a spending limit or usage alert. An unattended agent has no default spending ceiling
• Confirm whether unused credits roll over or reset monthly before you plan work around them

Say it like a dev

Instead of: “Why did this session cost so much?” Say: “This conversation is long. Can you /compact or summarize progress so far, so future turns don’t resend the whole history?”

Instead of: pasting an entire file into the chat Say: “Read just the processPayment function in checkout.ts instead of me pasting the whole file. That keeps input tokens down on every turn after this one.”

Instead of: “Is this going to be expensive?” Say: “What’s the input/output token split on this task, and can we lower the reasoning effort to cut down on output tokens?”