Getting VS Code As Close to Cursor as Possible — For Free!

Outline:

1. Background

2. How to

3. ???

4. Profit

Background

If you do not like hyperbole and stories, maybe skip this…

I’ve been struggling with Cursor’s new pricing model. Just last month (September 2025) I thought I was officially on the vibe-coding train.

I planned, built, and shipped an app to the iOS App store in 4 days. 4 DAYS! That’s 4 days including Apple’s review process.

Life was good. I was coding at warp speed.

I couldn’t believe this was real life. I’m still processing the significance of this tool.

It quickly became normal for me to go straight to Cursor before writing my own code. I developed a routine of talking through instructions with ChatGPT to make sure I filled in all the gaps of communicating to Cursor exactly what I wanted before I began. I then copied my final set of ChatGPT generated instructions into Cursor and let it run. I watched as Cursor crunched through files, creating new ones and editing the UI in real time. I saw my ideas quickly come to fruition. When things didn’t quite look right, I told Cursor “this sucks” and it seemed to somewhat intuitively know what I meant when I said “make this actually look good.” I thought I was starting to catch a glimpse of what vibe-coding was all about.

After October started, reality set in. My Cursor plan renewed, and I ran out of usage in about 3 days… 😭.

If you weren’t aware, Cursor used to allow unlimited usage of cheap models. Back in June they communicated that there was a price change coming, and as of October 2025 there is now no longer any way to get unlimited usage.

Having the impulse control to not press the button to setup on-demand usage was difficult, but I persisted. However, this was the first time Cursor’s new pricing model was effective on my account, and before now I hadn’t realized just how quickly I had become so dependent on the tool. At this point, being the cheapskate that I am, the only alternative to Cursor now available to me was GitHub Copilot built into VS Code — I was completely unwilling to pay for on-demand usage.

If the current implementation of GitHub Copilot (as of October 2025) is enough for your needs, you can stop reading right now. My take is that GitHub Copilot is currently unusable for the tasks I want. After starting on VS Code, switching to Cursor and now attempting to switch back to VS Code, I have realized that there is no going back. Thus, the pain and desire to go back to Cursor lingered and grew. I suffered through the agony of writing my own code for 2 weeks.

I conceptualize the invention of a tool like Cursor to the invention of a calculator. Why would I write my own calculations by hand, when I can simply plug the numbers into a calculator? Why would I write some of the most basic bits of code when I can have Cursor do it and then I check its work? When something complex is needed, I can simply double and triple check Cursor’s work, making my own tweaks and working together with it. Eventually I refactor the bits that need to be refactored, but having the scaffolding already setup is a huge leg up.

The reasons Cursor is superior to Copilot comes down to a few factors. One of the main factors is project indexing. Basically, Cursor creates text embeddings for all the files in your project and uses these text embeddings as context in your chats. Copilot does nothing of the sort (but there is an alternative that does, I’ll mention below).

With the desire to go back to Cursor and my unwillingness to actually fork up money at conflict with each other, I worked through that tension by seeking for some way to get the Cursor-like experience without actually paying for it. And that is how I stumbled upon Continue.dev. I will not explain what it is, you can figure that out on your own, but in simple terms Continue.dev is the Cursor alternative that I needed, and the best part is that I can use it for free with a little setup.

How to use Continue.dev to replicate Cursor

I’ve already written a story that is 3 minutes too long to read, so let’s just get to the point. The process is very straightforward.

1. Install the Continue.dev VS Code extension: https://marketplace.visualstudio.com/items?itemName=Continue.continue

2. Create a few gmail accounts (at least 3 is nice)

3. Grab some free API keys with your new gmail accounts, I recommend Groq, Mistral, Cohere and Gemini (Mistral requires a phone number for each account, so you may want to use your primary number and then setup a google voice number for one of your new gmail accounts)

4. Create one Agent per account inside of Continue’s settings, using Mistral for autocomplete, Cohere for reranking, and Gemini / Groq models for conversations and file edits

5. Swap between Agents as you talk to Continue, cycling through your API keys

It’s really that simple. Continue makes it very simple to get started, and very simple to select models and API keys for them.

Below is an example agent setup yaml file. You will want one per account, located under [your project]/.continue/agents:

name: xxx
version: 1.0.0
schema: v1
models:
  - uses: google/gemini-2.5-pro
    with:
      GEMINIAPIKEY: xxx
  - uses: google/gemini-2.0-flash
    with:
      GEMINIAPIKEY: xxx
  - name: Codestral
    provider: mistral
    model: codestral-latest
    apiKey: xxx
    roles: [autocomplete]
  - name: Autodetect
    provider: groq
    model: AUTODETECT
    apiKey: xxx
  - name: Cohere Reranker
    provider: cohere
    model: rerank-english-v3.0
    apiKey: xxx
    roles:
      - rerank

Before adding your config files, if you want to get a feel for how to setup on yourself, adding your first API key is as easy as going to the Models tab, choosing a provider, and adding a key.

And the result of adding several agents is that we end up with this:

At the end of setup, I get a Continue window in the right side panel of VS Code where I can easily swap between my API keys.

Some caveats

While this is all good, a few things I’ve noticed while working this way is that I need to keep my chat histories short. Continuing to talk to Gemini 2.5 Pro in a longer and longer conversation inevitably leads to larger token input and output. As I sit here now, it’s clear that hitting rate limits is a real problem. This was the philosophy behind using multiple API keys. You can easily avoid the problem below by maintaining conversations with less than 125K tokens per minute.

Of course, the only way to avoid 125k tokens per minute is to avoid using any more than 125k tokens per request. Even if you have 1 request at 125k tokens, you’re finished with the free plan. You can also use a different gemini model to get higher limits.