Local LLM Coding Now Hits 75% of Cloud AI

Local LLM coding now nears cloud AI on a 2022 Mac

Boykis did not upgrade her hardware to get here. Her machine is a "2022 M2 Mac" with 64GB of memory, already several years old when she wrote the essay.

On that unremarkable machine, she reports agentic coding loops that land at roughly 75% of the accuracy and speed of frontier cloud models. A Mac from 2022, not a new purchase, is what reaches that 75% mark.

The 75% number matters less than how quickly it arrived. Local LLM coding used to have a reputation for being slow and unreliable, fine for toy demos but not for a real workflow. Her evidence is a change in her own habit: she used to check every local answer against a cloud model, and now she does that a lot less often.

The models and tools behind local LLM coding

Boykis runs only quantized, open-weight models day to day. Google's "Gemma 4" family (gemma-4-26b-a4b, gemma-4-12b-qat), Alibaba's "Qwen 3 MoE" and "Qwen 2.5 Coder," and OpenAI's open-weight "GPT-OSS-20B" cover most of her coding work. She moves between three inference tools depending on the task: "LM Studio" for a GUI-driven workflow, "Ollama" for quick local serving, and "llama.cpp" when she wants low-level control.

The tasks she hands to this stack share one trait: they are self-contained and do not need anything from the live web. Splitting a notebook-style script into several proper modules, cleaning up lint errors around type hints, writing unit tests, proofreading draft posts, and scaffolding a recommendation-system repo all fit that description. None of these tasks needed a fresh web lookup or a novel design call, and that is what local LLM coding is good for right now.

Local LLM coding beats cloud AI on cost, not always speed

Once the hardware is paid for, a local model carries no per-token bill and no rate limit, but it still trails the frontier on accuracy and speed. Boykis's own yardstick is the 75% figure above: good enough for routine loops, short of the best cloud models. A cloud API, by contrast, keeps charging for every request regardless of how routine the work is.

The gap is built into how each option is billed, not a one-off discount. The more of your day is routine, self-contained coding, the more of it can move to a machine you already own without a monthly bill growing alongside it.

Open-weight releases are driving the local LLM coding boom

The models Boykis uses come from a wider shift. OpenAI, Google, and Alibaba have all shipped capable models as open weights in the same stretch of time — "GPT-OSS," "Gemma 4," and "Qwen."

Performance that used to live inside a paid API is now something anyone can download and run. The more capable the open-weight releases become, the less local LLM coding depends on any single vendor's roadmap.

Local LLM coding still cannot handle production work

The 75% figure is easy to over-read. Boykis herself is direct about the limit: she is not sure local models are ready for production software development yet.

Checking the latest library specifications, making large-scale architectural calls, and any task where being wrong is expensive still favor a top-tier cloud model with live access to current information. Local models split the work with cloud AI rather than replacing it: the routine, self-contained slice of the work goes to local models, while the hard, fast-moving remainder stays on paid APIs.

There is also a risk that a pure accuracy comparison misses. Unlike a cloud API, a local model file is something you download and trust. Pulling a quantized checkpoint from a public registry means trusting its provenance, and IDE plugins that wrap a local model for convenience can quietly add their own telemetry, so a privacy-motivated setup still needs a look at what the surrounding tooling sends out, not just at the model weights.

Local LLM coding for individual developers starts on the PC you own

For an individual developer or a small team, the first gain shows up on the bill. Per-token billing and monthly API charges go away, replaced by a one-time, predictable hardware cost. Source code and customer data never have to leave the machine, and provider-side rate limits no longer apply.

A second, quieter benefit is independence from any single vendor's access restrictions, pricing changes, and outages. That benefit matters most in fields like law, medicine, and public administration, where some documents simply cannot go to a cloud API at all. The trade-off is real too: the upfront cost of a machine with roughly 64GB of memory, plus the learning curve of choosing a model, quantization level, and inference engine.

The lower-risk first move is not to buy anything — it is to load a quantized model on the PC you already own and see how far it gets your routine work. A quantized "Qwen 2.5 Coder" or "Gemma 4" running through "Ollama" is a reasonable place to start that test.

Local LLM coding handles the routine work, cloud AI handles the rest

Local LLM coding has reached the point where routine, self-contained work — refactoring, test generation, proofreading — can finish on your own machine. The realistic way to balance cost and quality is to route the everyday, routine share of the work to a local model and reserve the cloud for the latest library specifics and the harder slice of work where a mistake is expensive. The lowest-risk way to find out where the split falls for your own workload is the one Boykis's report already points to: load a quantized model on the machine you have, and test it against what you actually do every day.