Can I run a Copilot-style coding assistant locally?

Yes — Ollama serving models plus the open-source Continue extension in VS Code is the standard 2026 stack. Use a small 1.5–3B model for instant tab-autocomplete and a 7–14B coder model for chat and edits.

Which models are best for local coding?

The Qwen2.5-Coder family leads across tiers, with Codestral, DeepSeek-Coder and Devstral as alternatives. Match the chat model to your VRAM: a 7B on 6 GB, a 7B Q8 or tight 14B on 8 GB, and comfortable 14B+ on 16 GB.

How much VRAM do I need for a pleasant experience?

6 GB is where local coding gets pleasant, around 30 tok/s on a 7B model. Even a CPU-only laptop with 16 GB RAM runs useful autocomplete, because completions need small models rather than big GPUs; 8–16 GB buys smarter chat, not faster typing.

Why run a coding assistant locally instead of using cloud Copilot?

Privacy and compliance — your code never leaves the machine, which is decisive for client codebases, NDAs and regulated work. It also works offline on trains and planes, and costs nothing per month with no per-seat bill.

Does a local assistant match cloud Copilot?

Not on everything. Local wins on autocomplete and routine chat; frontier cloud models still win on large, messy, cross-file refactors. Most people who go local end up hybrid: local for the daily 90%, cloud for the hard 10%.

Run a Local AI Coding Assistant on a Used Laptop: Copilot Without the Cloud (2026)

A local coding assistant — autocomplete and chat that run entirely on your own machine — is one of the most practical AI workloads for a used laptop: the models are small, the latency requirements are modest, and the privacy case is real. This guide covers the 2026 stack, which models fit which VRAM tier, and where local honestly still loses to cloud Copilot.

Why bother, when Copilot exists?

Three reasons that survive contact with reality. Privacy and compliance: your code never leaves the machine — decisive for client codebases, NDAs, healthcare/fintech work, and any business where “we pasted the repo into a cloud tool” is an awkward sentence. Offline: trains, planes, flaky hotel Wi-Fi. Cost: £0/month against per-seat subscriptions, on hardware you already bought for other AI work.

And one honest counter-reason: frontier cloud models remain smarter about large, messy, multi-file problems. Local wins on autocomplete and routine chat; the cloud still wins on “refactor this whole module”. Most people who go local end up hybrid.

The stack: Ollama + Continue

The 2026 default is boring and good: Ollama serves models locally; Continue (open-source VS Code/JetBrains extension) wires them into your editor with two roles — a small, fast model for tab-autocomplete and a bigger one for chat/edit. Alternatives exist (LM Studio as server, Cody, Twinny), but Ollama+Continue has the most documentation and the least friction.

The two-model split matters because the jobs differ. Autocomplete needs the first token in well under half a second — that means a 1.5–3B model, always loaded. Chat tolerates a second or two of thinking — that’s where your VRAM budget goes.

Models by VRAM tier (2026)

The Qwen coder family remains the local benchmark leader across tiers; Codestral, DeepSeek-Coder and Devstral are credible alternatives. Match the model to your card, remembering the KV cache adds 1–4 GB on top of the download at working context sizes:

Your hardware	Autocomplete model	Chat model	Experience
CPU-only, 16 GB RAM (T14 Gen 3)	Qwen2.5-Coder 1.5B	7B Q4, ~4–5 tok/s	Autocomplete OK; chat for patient moments
4 GB VRAM (P14s Gen 2, XPS 15)	1.5B on GPU	7B Q4 partially offloaded, ~10–18 tok/s	Autocomplete snappy; chat usable
6 GB (Legion 5 Gen 6)	1.5–3B	Qwen2.5-Coder 7B Q4 fully on GPU, ~30 tok/s	The budget sweet spot
8 GB (Legion 5 Gen 7, ZBook Fury G8)	3B	7B Q8 or 14B Q4 (tight), ~20–35 tok/s	Genuinely pleasant daily driver
16 GB (P15 Gen 2, Legion 7, Precision 7560)	3B	Qwen coder 14B Q4 comfortably; 20B+ class with room for context	Closest to cloud quality locally

(Tok/s figures are estimates from comparable community benchmarks; your quantisation, context length and RAM configuration all move them.)

Rule of thumb for quality expectations: 7B coder models are strong at completions, boilerplate, tests and explaining code; 14B+ adds noticeably better multi-step reasoning and edit coherence; nothing local matches frontier cloud models on gnarly cross-file refactors — see the honest limits below.

Five-minute setup

Install Ollama (Windows build is fine — see Windows vs Linux; this workload needs no WSL2).
ollama pull qwen2.5-coder:1.5b and ollama pull qwen2.5-coder:7b (swap sizes per the table).
Install Continue in VS Code; in its config, point the autocomplete role at the 1.5B and the chat/edit roles at the 7B on http://localhost:11434.
Set autocomplete maxPromptTokens modestly (~1–2k) — long prompts are what make local tab-complete feel laggy.
Test: type a function signature, wait for the grey ghost-text; highlight a block and ask chat to explain it.

If completions stall, check Ollama kept both models loaded (ollama ps) — model swapping on every keystroke is the classic misconfiguration on 6 GB cards. Keep the autocomplete model small enough that both fit simultaneously.

Honest limitations

Local assistants in 2026 are excellent line-and-function tools and mediocre architects. Context windows are configured small for speed, so repo-wide awareness is shallow; agentic multi-file edits work but with more babysitting than cloud tools; and on a battery-powered laptop, constant inference costs you roughly an hour of runtime — plug in for long sessions (thermals matter too). The pragmatic pattern for business users: local for the 90% of daily completions and quick questions (privacy preserved, latency great), a cloud model deliberately invoked for the hard 10%.

Summary

Ollama + Continue in VS Code is the standard 2026 local stack: a 1.5–3B model for instant autocomplete, a 7–14B coder model for chat.
6 GB VRAM is where local coding gets pleasant (~30 tok/s on a 7B); 8–16 GB buys smarter chat models, not faster typing.
Even a CPU-only £350 ThinkPad runs useful autocomplete — completions need small models, not big GPUs.
The privacy case is the killer feature for business: code never leaves the machine, and there’s no per-seat bill.
Stay hybrid: local for daily completions, cloud for repo-scale reasoning — pretending otherwise disappoints in week one.