I spent two years with GitHub Copilot. Paid the monthly fee, got decent completions most of the time, occasionally watched it hallucinate imports that didn’t exist. Then I started running Ollama in my homelab and realized I could ditch the subscription entirely. Migrating to Continue for local LLM-powered code completion wasn’t frictionless, but it solved a problem I didn’t fully know I had: not owning my autocomplete.
Why I Left Copilot
The reason wasn’t dramatic. Copilot works. It’s fast because it’s running on Microsoft’s infrastructure, and it’s genuinely useful for scaffolding boilerplate and remembering syntax I’ve forgotten. The problem was the opposite of useful: the more I relied on it, the less I liked not knowing what was happening with my code.
Every keystroke you accept gets logged somewhere. Copilot pulls training data from public GitHub, which is fine, but the interaction itself is proprietary. I’m not paranoid about this — I didn’t have secrets in my IDE when using it — but I started asking myself why I was comfortable outsourcing my thinking to a black box when I could run models locally.
There was also a practical angle. My internet connection at home isn’t terrible, but it’s not fiber either. Copilot sometimes stuttered. Nothing catastrophic, but noticeable enough that I’d notice. A model running on my 2080 Ti three feet away wouldn’t have that problem.
The real decision-maker was simpler: I already had the hardware. Ollama was already running. The friction to switch to Continue was lower than I expected.
Continue vs Copilot: What’s Actually Different
The most obvious difference is speed depends entirely on your hardware. With Copilot, you get consistent latency because it’s cloud-backed. With Continue and a local model, you get variable latency based on your GPU.
I run a Mistral 7B model on my machine most days. Completions take 1-3 seconds to generate. Copilot was usually 300-500ms. That sounds like a bigger deal than it actually is — you’re waiting either way — but the variance matters. Some days the GPU is bottlenecked by something else, and you notice the slowdown.
Continue’s strength isn’t speed. It’s flexibility. You’re not locked into one model. I can switch between Mistral, a quantized Llama 2, even Deepseek-coder depending on what I’m working on. The configuration lives in a JSON file in your project root. Change it, and Continue reconnects. No accounts, no authentication dance.
The chat interface feels similar to Copilot’s. You highlight code, ask a question, get an answer. The difference is the answer comes from your machine. In theory, that should feel more private. In practice, I don’t think about it much. I just notice I’m not wondering where my code went.
Copilot’s one advantage I genuinely miss: it understands your entire GitHub context. It can see your dependencies, your project structure, your commit history. Continue has basic context awareness, but it’s not as deep. You usually have to manually add files to the context window. That’s a step backward in some workflows.
Prerequisites and Hardware Requirements
Continue itself is lightweight. It’s a VS Code extension, weighs a few MB. The heavy lifting happens wherever your LLM is running.
For this setup, you need: VS Code or a JetBrains IDE, a local LLM running somewhere (probably via Ollama), and enough VRAM on your GPU to run a model that doesn’t make you want to scream. I wouldn’t try this with less than 6GB of VRAM. 8GB is comfortable. My 2080 Ti has 11GB and handles everything I throw at it without swapping.
If you’re running the LLM on the same machine as your IDE, you need enough GPU memory for both. If you’re running Ollama on a separate homelab server, network latency becomes the limiting factor — but that’s usually fine. Local network requests are fast enough.
CPU matters too, though it’s secondary. A faster CPU helps with prompt processing and context window handling. Nothing crazy, but don’t expect this to work smoothly on a Raspberry Pi 4.
Installing and Configuring Continue
The installation is straightforward. Open VS Code, search for Continue in the extensions marketplace, install it. Restart. Done.
The configuration is where you actually make decisions. Continue looks for a config file at ~/.continue/config.json. If it doesn’t exist, it creates one with defaults, which will try to reach out to cloud providers. You need to override this.
Here’s a minimal config that points to a local Ollama instance running on port 11434:
{
"models": [
{
"title": "Mistral 7B",
"provider": "ollama",
"model": "mistral:7b-instruct-q4_K_M",
"apiBase": "http://localhost:11434"
}
],
"tabAutocompleteModel": {
"title": "Mistral 7B",
"provider": "ollama",
"model": "mistral:7b-instruct-q4_K_M",
"apiBase": "http://localhost:11434"
},
"allowAnonymousTelemetry": false
}
Reload VS Code. Open the Continue sidebar (Ctrl+L in VS Code). You should see your model listed and ready to use. If it doesn’t connect, check that Ollama is actually running and listening on 11434.
One thing that caught me: tab autocomplete and chat completion can use different models. I run a smaller, faster model for inline completions and a larger one for chat. That’s optional but worth considering if you’re resource-conscious.
The First Week: Surprises and Adjustments
I expected Continue to feel like a downgrade. It wasn’t, but it wasn’t a straight replacement either.
The biggest adjustment was learning to be more explicit. Copilot’s deep context awareness meant I could hover my cursor and get suggestions without much prompting. Continue needs more hand-holding. I highlight code, describe what I want, and ask. It’s more like pair programming and less like autocomplete, which honestly took getting used to.
Accuracy was a surprise in both directions. For simple, common patterns — destructuring an object, writing a for loop, importing a library — Continue’s suggestions are nearly as good as Copilot’s. For domain-specific code or quirky patterns, it struggles. That’s not a flaw in Continue; it’s a flaw in running a 7B model. A 70B model would be better, but I’m not running that on my hardware.
The local-only aspect did feel strange at first. There was this moment, maybe day three, where I caught myself waiting for something to sync to the cloud. It didn’t, because it never left my machine. That took some mental adjustment.
Hallucinations happened. Not often, but Mistral would occasionally suggest imports or function signatures that were entirely fabricated. Copilot does this too, but maybe less frequently because it has more training data. I learned to treat both with skepticism.
Offline Capability and Context Management
Here’s something I didn’t expect to value until I had it: Continue works when your internet is down. Completely. You can sit on a plane, in a coffee shop with no wifi, anywhere, and still get code completions.
In practice, I’m rarely that offline. But the psychological comfort of knowing I could be is real. There’s no dependency on external services. The model is right there.
Context management is where Continue shows its scaffolding. You can add files to the context manually, and Continue will consider them when generating completions. There’s a sidebar where you toggle which files are in scope. It’s clunky compared to Copilot’s automatic awareness, but it works, and it’s deterministic. You know exactly what context the model sees.
The context window is configurable per model. Mistral 7B has a 32K token context window, which sounds huge until you realize that’s about 24,000 words. In practice, I rarely fill it, but knowing I can is useful.
Common Issues and Workarounds
Connection failures were the main pain point during migration. If Ollama crashed or became unreachable, Continue would hang or throw errors. The solution is straightforward: keep Ollama running via systemd or Docker. I use a docker-compose service that auto-restarts on failure.
Model incompatibilities are worth knowing about. Continue expects models to follow a specific API format. Ollama handles this for most popular models, but if you’re pulling something exotic, verify it’s compatible first.
Performance degradation happens if your GPU is already maxed out. Running a game, rendering video, or training a model will tank Continue’s responsiveness. I learned this the hard way. The solution is either better hardware or accepting that you can’t do everything simultaneously.
One issue I haven’t fully solved: switching models mid-session. Continue doesn’t handle this gracefully. Reload VS Code if you change your config. It’s not a blocker, just annoying.
Three Months Later: Still Using It
I’m still using Continue. Not because it’s better than Copilot — in raw capability, Copilot probably wins — but because the trade-offs align with how I think about my homelab.
I save the monthly fee. I own the setup. I can modify it, understand it, and change it whenever I want. That’s worth the occasional slower completion and the need to keep hardware running.
Would I recommend it to everyone? No. If you work in a team, if you need maximum accuracy, if you value consistency over ownership, Copilot is probably the right answer. But if you run a homelab, if you’re comfortable with local-first tooling, if you want to see how the sausage is made, Continue is worth a weekend to set up.
The thing that surprised me most: I don’t think about it anymore. It’s just there. I write code, I get suggestions, sometimes they’re good, sometimes they’re not. That’s enough.
FAQ
Can I use Continue with Copilot running at the same time?
Yes. They can coexist in VS Code. You’d have both extensions loaded and could switch between them. Most people don’t — there’s little reason to pay for Copilot if you’re already running Continue — but technically it works.
What models work best with Continue for code completion?
Mistral 7B, Deepseek-coder, and Llama 2 are popular choices. For better accuracy, Mistral Medium or larger models help, but they require more VRAM. Quantized versions (Q4, Q5) give you a good balance of speed and quality on consumer hardware.
How much GPU memory do I need to run Continue locally?
For a quantized 7B model, 6GB of VRAM is the minimum. 8GB is comfortable. If you want to run larger models or have multiple services competing for GPU memory, 12GB or more is better. CPU-only is possible but produces completions slowly — usually too slow to be practical for autocomplete.
Does Continue work if my LLM is on a different machine?
Yes. Point the API base to your Ollama server’s IP and port (e.g., http://192.168.1.50:11434). Network latency will be noticeable compared to local, but it works fine for most workflows. Keep your homelab network stable, and you won’t have problems.
Is Continue as accurate as Copilot for professional code?
Not consistently. Copilot has more training data and stronger models backing it. Continue’s accuracy depends on which model you run and the complexity of your code. For common patterns, they’re comparable. For specialized or unusual code, Copilot tends to win. Neither should be trusted without review.
Explore Continue in our AI Homelab Toolkit.