Local models running on consumer hardware will never outperform the top cloud models. That’s not going to change. More VRAM, faster interconnects, and training runs that cost millions aren’t going to disappear overnight. If you want the absolute best reasoning or most nuanced analysis, you’re going to pay for it and send it to OpenAI, Anthropic, or whoever leads the curve that week.
But here’s what gets overlooked: “best” isn’t the same as “good enough”. And for day-to-day tasks, local models might already be good enough. Using local models is becoming more and more popular thanks to rising token costs on one hand and progress in local models on the other.
Yesterday, when I was looking at another feature request, I got a crazy idea. I wanted to see whether local models could produce useful results using my office workstation has a fairly standard setup: a 16GB Nvidia RTX 5070 Ti and 32GB of RAM. Nothing exotic. It’s the kind of machine a developer or small team most likely already has at their desk.
How Local Models Compare to Cloud Models
I picked a real, small feature request from Deck’s backlog — nothing grand, just a single well-scoped improvement. I pasted the same prompt into two different models and let them write implementation plans, a plain MD file, not code yet.
First, Claude Opus 4.8. Probably the most popular choice now when you want a serious answer. It produced a solid plan: broken down into phases, with clear steps, edge cases called out, and a reasonable timeline.
Then I gave it to my local Qwen3.6-35B. Same prompt, same feature request, same constraints. The local models version came back with a plan that was genuinely competitive, or at least long enough to look so. Btw, it came back quickly, kinda the same speed as Claude. Same structure, same level of detail, same attention to edge cases.
But I didn’t dive too deep into it, and decided to outsource this work to a third AI 🙂
Testing Local Models: The Results
To avoid bias, I anonymized both plans and sent them to OpenAI, asking it to evaluate which was better and explain its reasoning:
And what came back surprised me:
”
Verdict
The stronger plan is human-readable-time-entry-input.md — the second plan. Since the files do not identify model names, I would say: the model that generated human-readable-time-entry-input.md did the best.
It is more implementation-ready, more technically accurate, and safer for the existing codebase.
”
The second plan actually was written by Qwen3.6.
I’m not going to post the whole output here, but I will add only the comparison table to be more reasonable:
Final score
| Category | First plan | Second plan |
|---|---|---|
| Scope control | 6/10 | 9/10 |
| Technical correctness | 4/10 | 9/10 |
| Yup validation approach | 3/10 | 9/10 |
| Edge cases | 5/10 | 8/10 |
| Implementation readiness | 6/10 | 9/10 |
| Verification steps | 5/10 | 9/10 |
Winner: second plan — human-readable-time-entry-input.md.
Conclusion
Let me be clear: I’m not writing this to declare a winner between models. Qwen vs Claude vs whatever comes next — it doesn’t matter. What matters is the implication.
A 35B-parameter local model running on hardware that fits on a desk, with no monthly bill, no API rate limits, and no data leaving your network, can produce output that an evaluator with access to the very best cloud models can’t reliably distinguish from them.
Here’s the takeaway: you don’t always need the top model. You just need a local model that’s good enough for the job. And the line between “good enough” and “the best available” keeps shifting lower.
The Qwen3 family has been making waves in the open-source community, with models ranging from 0.5B to 110B parameters. The 35B version I tested strikes a balance between capability and accessibility — it fits on a single consumer GPU while still delivering serious performance.
Meanwhile, cloud models like Claude Opus from Anthropic and GPT-5.5 from OpenAI continue pushing the frontier. But frontier doesn’t always mean practical. For many day-to-day tasks — writing implementation plans, summarizing documentation, generating code — the gap between top-tier cloud models and capable local models is closing fast.