If you’ve been coding anytime in the past year, you’ve probably heard the buzz about Cursor — the AI-powered IDE that promises to write your code, clean your code, and maybe even refactor your soul.

It’s built on top of VS Code, so it feels instantly familiar.
But the moment you hit that shiny AI shortcut, you realize: this thing is smarter than your codebase and hungrier than your wallet.

After a few months of using Cursor — and after accidentally vaporizing a scandalous number of API tokens — I’ve learned how to stay productive and solvent.
And yes, the TL;DR is that you can still combine Cursor with Ollama + local models to get many of these benefits for free.
Here are my 8 hard-earned tips to make Cursor your loyal sidekick within the limits of your budget.

The #1 tip: Control context scope aggressively – This is the biggest win

Cursor auto-includes files, diffs, and history—this explodes token usage.

Do this:

• Manually select only the exact files/functions needed
• Avoid “entire repo” context unless absolutely required
• Use @file and @selection instead of implicit context
• Clear chat or start a new thread when switching tasks

Why it matters:
Token cost scales with every line in context, not just your prompt.

Below are a bit more tips:

1. Master the Keyboard Shortcuts

Cursor gives you a few shortcuts that decide how fast — and how costly — your workflow will be:

• Cmd+K (or Ctrl+K) – Inline edits. Quick, cheap, efficient.
• Cmd+L (or Ctrl+L) – Opens the chat panel for longer, more contextual discussions.
• Cmd+I (or Ctrl+I) – Composer mode. Similar (in a way) to the last option. It’s open the side chat panel.

Pro tip: Cmd+K is your best friend. It’s fast, lean, and barely sips tokens.
Example:
Select a function (in your code) → Cmd+K → “Add try/catch and return an error.” Done.
No drama, no long chats, no token bonfire.

2. Be Ruthlessly Specific About Context

Cursor sends everything you select — or worse, the entire file — to the AI model. That’s like paying for a buffet when you only wanted a coffee.

Bad:
“Fix this bug.” (Cursor: “Sure! Let me read your whole repo and send you the bill.”)

Good:
Select just the problematic function → Cmd+K → “Add null check for userId.”

Even better, pre-mark tasks with a TODO:

// TODO: Add validation for userId
function getUserData(userId) {
  // existing code
}

Cursor actually behaves better when you make it earn its code. Tell it:

“Write Jest tests for this feature first, then write the code to make them pass.”

In our Node backend, Cursor generated unit tests for a new endpoint, then implemented the handler — and re-ran the tests until green.

Cursor like (a lot) TODOs.
They give it purpose and boundaries — both of which save you money.

3. Use .cursorrules — Your AI’s North Star

Create a .cursorrules file in your project root.
This is where you tell Cursor, once and for all, how you like things done.

Example:

{
  "naming": {
    "variableCase": "camelCase",
    "classCase": "PascalCase"
  },
  "imports": {
    "preferTypeOnly": true,
    "disallowDefault": true
  },
  "patterns": [
    "Always use async/await over Promises",
    "Never commit console.log statements",
    "Use zod for runtime validation"
  ]
}

# Or
# Project Guidelines
- Use TypeScript strict mode
- No console.log in production
- Use async/await
- Write tests for new functions
- Tailwind for styling
- Error handling required for all API calls

Now when you ask Cursor to “Build a signup component,” it automatically respects your rules.
Less explaining. Fewer tokens. More consistency.

4. Use @ Mentions Like a Sniper

Be explicit with context using @:

• @filename.ts – include a specific file
• @docs – include docs
• @web – let Cursor fetch from the web (careful, this costs extra)
• @codebase – full-repo context (aka The Token Inferno)

Smart usage:
“Update @UserService.ts to match interface in @IUser.ts.”
It’s clear, targeted, and cheap.

5. Break Big Tasks Into Snackable Pieces

Yes, Composer mode is powerful enough to build your entire startup.
It’s also powerful enough to bankrupt your token quota.

Break complex tasks into smaller, cheaper requests:

1. “Create User interface in @types/User.ts”
2. “Implement AuthService in @services/auth.ts using bcrypt”
3. “Add password reset method to AuthService.”

You’ll get better results, lower costs, and way fewer “wait, what did you just rewrite?” surprises.

6. Switch to Normal Autocomplete When You Don’t Need Magic

Cursor has two autocomplete modes:

• Cursor Tab: AI-powered, fancy, occasionally psychic.
• Normal Mode: Basic, fast, token-free.

If you’re writing boilerplate, imports, or obvious patterns, switch to Normal Mode.
Reserve Cursor Tab for new logic or tricky algorithms.

Toggle it in Settings → Features → Cursor Tab.

7. Cache, Ignore, and Localize

First, make sure Cursor isn’t analyzing junk directories every time.
Create a .cursorignore:

node_modules/
dist/
build/
.next/
coverage/
.git/

That alone saves a surprising amount of tokens.

But here’s the new level-up: use local models for some of your work.
If you’re doing basic code cleanup, writing docs, or generating boilerplate — you don’t need GPT-5-level brainpower for that.

Try Ollama. It lets you run open models (like Llama 3, Mistral, or CodeGemma) locally on your machine — fast (if you got a strong machine with a nice GPU), private, and free.
You can connect it with your workflow via the Cursor “custom model” option, or run it in parallel for low-intelligence tasks like:

• Writing tests for obvious logic
• Commenting code
• Converting JSON to TypeScript
• Generating basic UI boilerplate

Use the big, fancy models only when the task actually needs deep reasoning.
Just like you wouldn’t call in a senior architect to rename variables, don’t waste top-tier tokens on trivial work.

8. Use the “Apply” Button Like a Grown-Up

When Cursor suggests changes, resist the temptation to smash Apply immediately.

• Apply: Instant merge. Dangerous.
• Review: View diff first. Reasonable.
• Edit: Manually tweak before applying. Pro move.

Each “try again” costs another round of tokens.
Review once, tweak manually, move on.

Bonus: Track Your Token (Diet)

Cursor’s Settings → Account panel shows your usage. Check it weekly.
You’ll quickly see which habits are burning money.

And yes — cheaper models exist inside Cursor too.

If you’re using GPT-5 for everything, consider switching to Claude 4 Haiku, Gemini 2.5 Flash, or OpenAI’s smaller models for non-critical edits.
They’re fast, cheap, and perfectly fine for 80% of daily dev work.

And another one: PRD first

Before starting a new feature, feed Cursor the product spec.
Example:

“We’re building a dark-mode toggle. Here’s the PRD section.”

Cursor then creates the settings UI, state management, and tests that actually match the requirements.

Impact: Cuts design-to-code time by ~50%.
Bonus: PMs will think you work weekends. (You don’t have to correct them.)

The Bottom Line

Cursor can easily 10x your productivity — or 10x your cloud bill.
It depends entirely on whether you treat it like a scalpel or a flamethrower.

• Be specific (and use /summarize to your context)
• Use .cursorrules
• Cache and ignore junk
• Split big tasks
• Mix models smartly (local + cloud)
• Review before applying

I’ve cut my Cursor costs by 62% since following these strategies… Please don’t ask how I got to this number 🙂

Have your own Cursor or Ollama hacks?
Drop them in the comments.
We’re all figuring out this AI-powered dev future — might as well help each other not go broke doing it.

P.S. Cursor Pro is worth it if you code daily.
Just remember: you can run a lot of local Ollama models before you even come close to that subscription price.