Written by: Mark Hull, Co-Founder and CEO, Exceeds AI | Last updated: July 13, 2026
Key Takeaways for Token Governance in Cursor and Claude Code
- Token costs for Cursor and Claude Code are rising quickly, and Gartner predicts AI coding expenses will surpass developer salaries by 2028.
- Focused context management using new chats per task, .cursorignore files, and selective @-mentions delivers substantial token savings on everyday development work.
- Model routing between Sonnet and Opus, prompt caching, and subagent isolation give you additional high-impact controls over usage-based pricing risk.
- Commit-level measurement turns guesses into facts. Exceeds Ink captures per-session token usage and interaction mode to produce verifiable, board-ready ROI proof.
- Turn token tactics into measurable outcomes and book a demo with Exceeds AI.
Prerequisites Before Applying These Token Tactics
This playbook assumes the following prerequisites are in place:
- Active Cursor and/or Claude Code usage across at least one engineering team
- GitHub or GitLab repo access with permission to install Git hooks
- Willingness to install Exceeds Ink, a lightweight, short-lived hook process (no long-lived daemon, no PATH-shimmed git binary) that writes a portable line-level attestation as a Git Note alongside every commit
- A baseline token spend figure pulled from Anthropic Console, Cursor team analytics, or your cloud billing dashboard
Without a baseline, savings percentages remain estimates. With Exceeds Ink installed, every step below produces a before-and-after delta at the commit level.
See how Exceeds Ink turns baselines into verified savings. Book a demo.
Step-by-Step: How to Reduce Token Usage in Cursor and Claude Code
Step 1: Start a New Chat for Every Distinct Task
Claude re-reads the entire conversation history on every message, so message 50 in a session costs more than message 5 purely due to accumulated prior context. Carrying a debugging thread into a feature build means every new prompt pays for all prior context, including tool call outputs that no longer matter.
To eliminate this compounding cost, adopt a simple discipline: one task, one session. When you switch tasks, open a new chat instead of continuing the existing thread. Starting a new conversation when switching tasks prevents irrelevant prior context from loading and removes the associated per-message token overhead.
Success criteria: Average session length drops, and per-session token cost stabilizes instead of growing quadratically through the day.
Verify with Exceeds Ink: Ink captures interaction mode and session boundaries per commit. After one sprint of enforcing new-chat discipline, compare average tokens per commit before and after in the Exceeds platform. The delta represents verified savings, not an estimate.
See your session-level savings in real data. Book a demo.
Step 2: Configure .cursorignore to Exclude Irrelevant Files
Cursor assembles context through codebase indexing and semantic search. Without explicit exclusions, it pulls in lockfiles, build artifacts, generated code, and test fixtures, which inflate token counts without improving output. Structured context tools that replace raw repository dumps with curated, filtered snapshots that strip generated code, lockfiles, and build artifacts deliver some of the largest gains.
A minimal .cursorignore for a Node.js project:
node_modules/ dist/ .next/ *.lock coverage/ *.min.js *.mapAdapt this pattern to your stack. The goal is to keep Cursor’s indexed context limited to files an engineer would actually open during the task.
Success criteria: Cursor context size per request visibly decreases, and token counts on equivalent tasks drop by roughly 20–40%.
Verify with Exceeds Ink: Ink reads token cost per agent session from Cursor’s state database for exact accuracy. Compare pre- and post-.cursorignore token costs on similar task types across commits.
Track .cursorignore impact at the commit level. Book a demo.
Step 3: Use Selective @-Mentions Instead of Full Codebase Context
Pointing Claude directly at the two or three specific files relevant to a task, rather than asking it to read the full repository, avoids loading and processing unnecessary files into context. In Cursor, this means using @filename references explicitly instead of relying on broad codebase search. In Claude Code, it means scoping file reads to the exact paths needed.
Sending 2,000 highly relevant tokens outperforms sending 20,000 loosely related ones for both cost and output quality. This principle, that focused context outperforms broad context, becomes a habit when you rely on selective @-mentions at the prompt level.
Success criteria: Input token counts per request fall, while output quality on scoped tasks stays steady or improves because context rot decreases.
Verify with Exceeds Ink: Ink’s line-level attestation shows which files were touched per session. Narrow sessions produce tighter attribution and lower per-commit token costs, which appear in the Exceeds dashboard within minutes of new commits.
Connect scoped prompts to lower tokens per commit. Book a demo.
Step 4: Tune the Effort Slider and Use /compact Aggressively
Claude Code’s auto-compaction summarizes conversation history near context limits, and engineers can also invoke /compact manually after exploration phases instead of waiting for the automatic trigger. As noted earlier, long sessions cause near-quadratic token growth. Running /compact after exploration phases directly addresses this compounding effect.
Cursor offers a complementary control through its effort slider, which governs how deeply the agent explores the codebase before responding. For well-scoped tasks with explicit file references, a lower effort setting reduces exploratory reads without hurting output quality.
Success criteria: Session token counts plateau instead of compounding, and context utilization stays in the recommended 60–80% utilization range instead of creeping toward limits.
See how compaction changes your cost curve. Book a demo.
Step 5: Route Tasks to Sonnet vs. Opus Based on Complexity
Model selection has a direct and often dramatic impact on cost. Using Claude Opus only for research, planning, and deep refactors while defaulting to Sonnet for code edits, bug fixes, and file-by-file work reduced one ML engineer’s weekly token usage by approximately 40% with no perceptible quality loss.
A practical routing heuristic:
- Sonnet: Bug fixes, single-file edits, boilerplate generation, test writing, documentation
- Opus: Architectural planning, cross-repo refactors, complex debugging sessions, security review
Routing the right task to the right model is the single largest lever for managing consumption-pricing exposure, because reasoning models cost 5 to 20× more than completion calls when used for boilerplate instead of complex refactors.
Success criteria: Opus usage drops to roughly 20–30% of sessions, and per-task cost falls without any increase in rework rates.
Verify with Exceeds Ink: Ink captures the underlying model behind each session and reports cost per agent and model. The Exceeds platform correlates model selection with shipped output, including lines attributed, commits produced, and session-to-merge velocity, so model routing decisions rest on outcome data instead of intuition.
Turn model routing into measurable ROI. Book a demo with Exceeds AI.
Step 6: Enable Prompt Caching for Repeated System Prompts
Prompt caching can cut input token costs by up to 90% by reusing static prompt portions. For teams using Claude Code with a shared CLAUDE.md or system prompt, enabling Anthropic’s prompt caching means the static portion of every session is served from cache instead of being re-processed.
Prompt caching on repeated system prompts yields major cost reductions for teams with stable, shared prompts. Once caching is active, monitor your cache-hit rate, because it serves as a leading indicator of prompt-engineering maturity.
Teams with high cache-hit rates have well-structured, stable system prompts. Teams with low rates pay full price on every turn.
Success criteria: Cache-hit rate rises above 70% on sessions using shared system prompts, and input token costs fall in line with that rate.
Correlate cache hits with real savings. Book a demo.
Step 7: Implement BYOK (Bring Your Own Key) with Anthropic for Cursor
BYOK in Cursor routes Claude API calls through your own Anthropic account instead of Cursor’s managed billing. This change unlocks direct access to Anthropic’s enterprise pricing tiers, prompt caching controls, and usage analytics at the API level, visibility that Cursor’s team analytics do not provide.
Native tools from model vendors provide only workspace- or seat-level aggregates and lack team-level attribution, commit-level cost linkage, cross-provider aggregation, and real-time preventive budget enforcement. BYOK becomes the prerequisite for closing that gap, because it surfaces the raw usage data that governance tooling like Exceeds Ink can bind to commits.
Success criteria: Token usage becomes visible at the API level per team, prompt caching is configurable, and cost anomalies are detectable before the monthly invoice arrives.
Verify with Exceeds Ink: With BYOK active, Ink correlates API-level token spend with commit-level output in the Exceeds platform. The result is a spend-to-outcome view that answers the question every engineering leader asks: what are all these tokens actually buying?
Connect API usage to shipped code. Book a demo.
Step 8: Isolate Heavy Context Work to Subagents
Delegating tasks that require reading many files, long analysis, or substantial tool output to subagents keeps heavy context accumulation isolated in separate sessions so it does not inflate costs in the main conversation. Claude Code’s subagent isolation runs tasks in separate windows and reports summaries, which prevents a large file-read operation from consuming the token budget of the primary session.
Success criteria: Main session token counts remain stable even on complex multi-file tasks, and subagent sessions stay bounded and predictable in cost.
See how subagent isolation shows up in your spend. Book a demo.
Validating Token Savings and Engineering Impact
These tactics only matter when you can prove their impact. A defensible before-and-after comparison requires three data points per tactic: token cost per session, tokens per merged PR, and rework rate on AI-touched commits.
A Jellyfish study of 12,000 developers across 200 companies found that higher token usage correlates with higher cost per merged PR, which makes cost per PR the most actionable unit for governance. Exceeds Ink captures this metric at the commit level instead of relying on vendor-reported aggregates.
After two sprints of applying the tactics above, compare the following:
- Average tokens per commit (Exceeds Ink, per-session capture)
- Model distribution across sessions (Sonnet vs. Opus ratio)
- Cache-hit rate on system prompts (Anthropic Console plus Ink correlation)
- Rework rate on AI-touched PRs versus baseline (Exceeds platform, longitudinal tracking)
Teams that instrument all eight steps typically land in the substantial savings range described earlier. Teams that apply only one or two tactics usually see 10–20% reductions that remain difficult to attribute with confidence.
Turn token savings into board-ready metrics. Book a demo.
Scaling Token Governance Across the Organization
Scaling these tactics across a 100–999 engineer organization requires more than a shared wiki page. Gartner recommends that software engineering leaders implement a disciplined operating model that includes mandating context engineering practices, implementing token thresholds and automated monitoring, and embedding token usage reviews into sprint retrospectives.
Exceeds AI operationalizes this model at three levels. First, Exceeds Ink’s per-commit attestation makes token spend attributable to specific teams, tools, and interaction modes instead of workspace-level aggregates. Second, the Exceeds platform’s Best Practices Insights surface the top patterns worth scaling across the organization, ranked by confidence instead of vanity metrics. Third, the ink-prompting-coach skill delivers coaching directly into engineers’ own Claude Code or Cursor agents, so governance appears where the work happens instead of in a separate dashboard.
Many organizations cannot clearly attribute AI spend to measurable business outcomes, according to Deloitte’s 2025 AI enterprise survey. The gap between token spend and shipped value represents a governance problem that requires commit-level instrumentation to close, not better spreadsheets.
Move from token spend to accountable AI governance. Book a demo.
Frequently Asked Questions
How much can I realistically save by reducing token costs in Cursor and Claude Code?
Realistic savings depend on current habits. Engineers who run long, unfocused sessions with broad codebase context and default to Opus for every task present the largest opportunity. Applying the full set of tactics in this playbook, including new chat per task, .cursorignore configuration, selective @-mentions, /compact usage, Sonnet routing for routine work, prompt caching, BYOK, and subagent isolation, consistently produces significant reductions on typical development tasks.
Teams that apply only one or two tactics usually see smaller and harder-to-verify gains. Measurement remains the key variable, because savings that are not captured at the commit level cannot be reported to leadership with confidence. Exceeds Ink’s per-session token capture provides the verification layer that turns tactics into proof.
Get commit-level proof of your token savings. Schedule a demo.
What is the difference between reducing token costs and reducing AI output quality?
Token cost and output quality do not move together in the way most engineers assume. Context rot, the degradation of model recall as the context window fills, means that larger contexts frequently produce worse outputs instead of better ones. Sending 2,000 highly relevant tokens outperforms sending 20,000 loosely related ones on both cost and quality dimensions.
The tactics in this playbook remove waste tokens such as irrelevant files, accumulated tool call outputs, and repeated system prompts rather than signal tokens. Rework rate on AI-touched commits is the quality metric to watch. If rework rises after applying these tactics, the context reduction went too far.
Exceeds AI tracks rework rates longitudinally on AI-touched code, so quality degradation becomes visible before it turns into a production incident.
Monitor both cost and quality for AI-generated code. Book a demo.
How does Exceeds Ink capture token costs without being in the request path between engineers and Anthropic?
Exceeds Ink never sits in the request path between your engineers and their AI vendors, and it makes no calls to Anthropic, OpenAI, or any AI provider. For Cursor, Ink reads token cost directly from Cursor’s state database for exact accuracy. For Claude Code, Ink uses a hook-direct model, invoked from standard Git hooks at commit finalization, that captures session metadata including token spend, model, interaction mode, and tool usage.
All data lands in a local SQLite database on the developer’s machine first. If Ink stopped collecting tomorrow, every AI tool would keep working exactly as it does today. The result is authoritative, commit-level token attribution without any proxy or interception layer.
See how Ink fits into your stack with zero proxying. Book a demo.
Can these token governance tactics be enforced at the team level, not just adopted individually?
Team-level enforcement prevents token costs from rebounding after an initial reduction. Exceeds AI supports policy enforcement through Ink’s structured JSON attestation in the repo, which serves as a natural input to policy engines and internal developer platform scorecards, and through the Coaching Surfaces feature that delivers guidance directly into engineers’ own AI agents.
The ink-prompting-coach skill installs into Cursor or Claude Code as a SKILL.md and slash command, so model routing guidance and context hygiene practices appear at the moment an engineer opens a new session instead of in a separate dashboard they must remember to check. Skill transfer and rollback allow engineering managers to distribute a verified pattern across the organization and retract it cleanly if it does not land.