How to burn fewer tokens in Cursor and Claude without making the work worse

This note is background; current work is Web & eCommerce packages and US → EMEA market entry.

There is a pattern we keep seeing in teams that adopted AI tooling enthusiastically in 2025 and are now staring at the invoice in 2026: the bill did not grow because the models got more expensive. It grew because nobody looked at what was being sent to them.

Here is the uncomfortable arithmetic. A model’s price per million tokens is a fixed, published number. What is not fixed is how many tokens your working habits generate — and for most operators using Cursor and Claude daily, the dominant spend is not clever output. It is the same context, paid for again and again: the repo files re-attached to every message, the system prompt re-sent on every call, the agent loop that re-reads half the project on each retry.

Context is the bill. Once you internalise that, cutting token burn stops being about finding a cheaper model and becomes about sending less, sending it once, and stopping loops before they wander. None of it makes the work worse. Most of it makes the work better, because the same discipline that saves tokens — scoped context, clear briefs, planned changes — is what makes model output more accurate in the first place.

This is a practical field guide, not a pricing essay. For the strategic version of the cost question — which model classes should carry which workloads — read our open vs frontier cost math. This post is about the habits underneath.

What actually burns tokens

Before tactics, an honest inventory. Five things dominate token spend in day-to-day assisted development, roughly in order:

Cost driver	Why it burns	The fix in one line
Re-sent conversation context	Every message in a long chat re-sends the accumulated history	Start fresh chats per task; keep threads short
Oversized context attachments	Attaching folders or whole repos when three files were relevant	Scope @ mentions to what the task touches
Unscoped agent loops	Each retry re-reads files, re-runs searches, re-explains itself	Plan first; give the agent a brief, not a wish
Repeated system/rules prompts	The same instructions re-sent, uncached, on every call	Stable prompt prefixes + prompt caching
Reasoning modes left on	Extended thinking multiplies output tokens on tasks that don’t need it	Match reasoning effort to task difficulty

Notice what is not on the list: the model’s list price. A team with disciplined context on a premium model routinely spends less than a team with sloppy context on a budget one — because the sloppy team sends ten times the tokens per unit of useful work, and then sends them again when the first attempt misses.

Cursor: scope, plan, and know when not to use the agent

Cursor is where most of the burn happens for development teams, because it is where the context lives.

Attach what the task touches, nothing more

Cursor’s own guidance is narrower than most people’s habits: use @ mentions when you know which files are relevant, and skip them when you don’t — the agent finds files through its own search, which is usually cheaper than a speculative folder dump (Cursor docs). Attaching @src/ because the answer is “somewhere in there” pays for every file in the folder on every message that follows.

The working rule: mention the two or three files the change touches. If you genuinely don’t know where the change lives, say so in the prompt and let the agent search — a targeted search costs a fraction of a pre-emptive dump.

Keep chats short and tasks small

Every chat shares a fixed context window, and as the thread grows, Cursor compresses older parts into a summary to make room. Long before that point, you are paying to re-send an increasingly stale history with every message. The habit that fixes it also happens to be good engineering: one task, one chat. Finish the change, verify it, start fresh. Smaller diffs are cheaper to produce, cheaper to review, and far cheaper to retry when something is off.

Plan before you let the agent loop

The single most expensive object in assisted development is the unscoped agent run: “fix the failing tests” against a codebase the model hasn’t mapped, retried three times, each attempt re-reading files and re-running searches. The token cost is bad; the review cost of a sprawling, half-right diff is worse.

The alternative costs one message: ask for a plan first. Have the model state what it thinks is broken, which files it will touch, and what the change looks like — then approve or correct before anything runs. A plan is a few hundred output tokens. A wandering loop is tens of thousands, plus your afternoon.

Write the stack down once, in rules

If you find yourself typing “we use Astro, custom CSS, no Tailwind, strings live in the i18n files” for the third time this week, that sentence belongs in a project rules file, not in your prompts. Cursor’s rules attach project conventions automatically — you stop paying attention (and tokens) to re-explaining your own stack, and the model stops making the class of error that comes from not knowing it.

Know when Agent mode is the wrong tool

Agent mode earns its cost when the model genuinely needs to search, read several files, make coordinated edits, and verify. For a rename, a single-function change, or a copy tweak, inline edit or a short scoped chat does the same job in one pass at a fraction of the tokens. Reaching for the agent by default is like taking a van to post a letter — it works, and you paid for the van.

Claude: cache the stable, shorten the system, discipline the tools

For teams calling the Claude API directly — for internal tools, agents, or pipelines — the levers are structural.

Prompt caching is the single biggest API lever

If your calls share a stable prefix — a system prompt, tool definitions, reference documents — prompt caching changes the economics outright. On the Claude API, cache reads are billed at 0.1× the base input price; cache writes at 1.25× (Anthropic’s prompt caching documentation). For a pipeline that sends the same 5,000-token preamble a few hundred times a day, that is the difference between paying full price a few hundred times and paying it roughly once.

The discipline it demands is architectural: keep the stable part stable. Put fixed instructions, tool definitions, and reference material at the front of the prompt, in a consistent order, and keep anything that varies per request at the end. One casually reworded sentence at the top of the system prompt invalidates the cache behind it.

Shorter system prompts outperform longer ones

System prompts accrete. Someone adds a paragraph for an edge case, someone else adds three examples, and a year later every single call carries 4,000 tokens of instructions — half of which the model would do correctly anyway. Audit it: remove instructions covering behaviour the model already gets right, collapse redundant examples, move rarely needed reference material into retrieval so it is fetched when relevant instead of paid for always.

Tool-use discipline cuts hidden round-trips

Agent workloads burn tokens in round-trips: every tool call and result cycles the accumulated context through the model again. Three habits shrink this:

• Narrow tool contracts. A tool that returns exactly what the agent needs beats a tool that returns a full record the model must sift — you pay for the sifting on every subsequent turn.
• Fewer, better tools. Every tool definition rides along in the prompt whether used or not. Prune the ones nothing calls.
• Bounded loops. Give agents an explicit budget of steps and a defined behaviour for hitting it. “Try until it works” is not an instruction; it is an open tab.

Match the model class to the task

Anthropic ships models at distinct capability and price tiers — as of this writing, Haiku-class for fast routine work, Sonnet-class for the daily balance, Opus-class for the hardest reasoning (verify current names and prices against Anthropic’s model overview, as they move). The pattern that holds across every generation: route by task, not by habit. Classification, extraction, formatting, and first-pass drafts do not need the top tier; deep architectural reasoning sometimes does. The same logic applies inside Cursor’s model picker — and extended thinking modes deserve the same scrutiny, since reasoning tokens are output tokens you pay for whether or not the task needed the depth.

Team rules: where the compounding happens

Individual habits save real money. Team habits multiply it — because the expensive failure modes are organisational, not personal.

One source of truth for stack knowledge. If every developer re-explains the architecture to the model in their own words, you pay for that explanation dozens of times a day — and every version differs slightly. A maintained project rules file (or a CLAUDE.md, or both) is written once, versioned in git, and attached automatically.

Ticket → brief → build. Work that reaches an agent should arrive as a brief: what to change, where, what done looks like, what not to touch. Briefs make agent runs shorter and more accurate. The vague ticket — “improve the checkout flow” — becomes an expensive archaeology expedition before any edit happens.

A human gate before “fix everything” loops. Broad, destructive-adjacent instructions — fix all tests, upgrade all dependencies, resolve every lint error — need a person approving the plan first. This is the same review-gate discipline we apply to production agent workflows, applied to your own tooling.

Look at the bill weekly, briefly. Not a dashboard project — ten minutes on the provider’s usage page. Spend spikes trace back to a workflow, a chat pattern, or one runaway loop, and each is fixable the moment someone notices. Spend nobody watches only ever moves in one direction.

Who should do what

Solo founder or operator. Adopt the free habits first: scoped attachments, fresh chats per task, plan-before-loop, one rules file. Skip infrastructure — no gateway, no dashboard. Your leverage is entirely in working habits, and it caps most runaway-bill scenarios on its own.

Five-person ops or product team. Everything above, plus the shared layer: a versioned rules file everyone inherits, briefs as the norm for agent work, one named person glancing at usage weekly. If you run API workloads, structure prompts for caching before optimising anything else — it is the largest single lever and it costs a refactor, not a platform.

Agency or delivery pod. Token spend is margin. Route by task class as policy, not preference; make cache-friendly prompt structure a build standard; put per-client attribution in place so cost sits next to revenue. At this point the question stops being tooling hygiene and becomes architecture — which model carries which workflow, logged and reviewable — and that is Operating Layer territory — we explain what an AI Operating Layer is separately, with the budgeting logic covered in our implementation cost breakdown.

The bill is a mirror

Token spend is unusually honest telemetry: it reflects, line by line, how your team actually works with these tools. Bloated context, vague briefs, and unwatched loops show up in the invoice before they show up anywhere else. Fix the habits and the bill follows — and so, quietly, does the quality of what the models give you back.

If you would rather have a second pair of eyes on it — which workflows are burning what, where routing or caching would pay, what a governed setup looks like for a team your size — start with a Web & eCommerce quote or US → EMEA.