# Why I Stopped Chasing the Newest LLM (And What I Run Instead)

> Source: <https://dev.to/samhartley_dev/why-i-stopped-chasing-the-newest-llm-and-what-i-run-instead-51h9>
> Published: 2026-08-29 08:02:10+00:00

There was a stretch last year where I downloaded every new model within hours of it dropping. Llama 3.1? Done. Mistral Nemo? Running. Qwen 2.5? Let me benchmark it at 2 AM on a Tuesday.

I was spending more time downloading, configuring, and benchmarking than actually building things. And the worst part? Most of the "upgrades" didn't change my daily output at all.

So I stopped. I picked a stack and stuck with it. And somehow, I'm getting more done now than when I had 40 models installed.

Here's what the cycle looked like:

In one month I downloaded 12 models. I actually used 3 of them regularly. The other 9 sat on my drive eating 180GB of SSD space.

The math was brutal: roughly 15 hours of my time that month on model management. That's almost two full workdays. For what? A 3% improvement on a benchmark I don't even care about?

I haven't changed my primary models since April 2026. Here's what I run and why:

| Machine | Model | Role | Why This One |
|---|---|---|---|
| Mac Mini M4 | Qwen 3.5 9B | Orchestration, routing, quick chat | Fast, solid at instruction-following, 9B is the sweet spot for 16GB RAM |
| Mac Mini M4 | Granite 3.2 8B | Writing, editing, summaries | Better prose than Qwen at this size. Less hallucination in creative tasks. |
| Windows PC (RTX 3060) | Qwen 3 Coder 30B | Code generation, refactoring | 30B is the smallest that reliably handles multi-file projects. Fits in 12GB VRAM. |
| Windows PC (RTX 3060) | DeepSeek R1 8B | Reasoning, debugging, analysis | The chain-of-thought on this model is genuinely useful for tracing bugs. |
| Ubuntu box | DeepSeek R1 (larger) | Heavy reasoning tasks | When the 8B isn't enough and I don't want to pay for cloud. |
| Ubuntu box | MinCPM-V | Vision tasks | Only vision model that runs reasonably on consumer hardware. |

That's it. Six models across three machines. I use maybe 4 of them daily.

This model handles 80% of what I throw at it. Routing decisions, summarizing articles, writing first drafts, parsing structured data. It's fast (under 2 seconds for most responses on the Mac Mini) and it doesn't hallucinate much at this size.

I tried replacing it with Llama 4 Scout when it came out. Same parameter class, theoretically better benchmarks. In practice? The Qwen model followed my system prompts more precisely and produced more consistent output formats. Benchmarks don't measure "does it actually follow instructions" — real usage does.

30B parameters is the minimum I've found for reliable multi-file code generation. Anything smaller starts forgetting what function it defined two files ago.

The RTX 3060 with 12GB VRAM runs this model in 4-bit quantization at about 12-15 tokens/second. Not blazing, but fast enough for code review and refactoring where I'm not sitting there waiting.

Could I get better results from a 70B model? Probably. But a 70B model doesn't fit on a 3060, and I'm not buying another GPU just for marginally better code suggestions.

This one surprised me. The chain-of-thought reasoning in R1 is genuinely useful, even at 8B. When I have a tricky bug or a design decision, I run it through R1 first. It often surfaces edge cases I missed.

The 8B version is the minimum viable reasoner. For really complex stuff, I bump up to the larger version on the Ubuntu box. But 8B handles 90% of my reasoning needs.

Most people don't know this model well. IBM's Granite series doesn't get the hype of Llama or Qwen. But for writing tasks — summarizing, editing, rephrasing — it's noticeably better than Qwen at the same size.

It produces cleaner prose with fewer awkward constructions. It also hallucinates less on factual summaries. I use it for all article drafts and content work.

Let me be honest about the trade-offs:

**I'm probably 5-10% behind the frontier on code generation.** The latest Claude or GPT-4o will write better code than my 30B Qwen. But I'm not paying $200/month for 5-10% better code that I still have to review anyway.

**I'm definitely behind on very long context tasks.** If I need to analyze a 50-page document, local models with 8-32K context windows can't compete with Gemini's 1M+ window. I still use cloud for those specific tasks — about 15% of my workload.

**I'm missing out on multimodal advances.** The vision models I run are functional but not impressive. GPT-4o Vision and Gemini Pro Vision are significantly better. I use cloud for complex vision tasks.

But here's the thing: I know these gaps. They're predictable. And I've built workflows that route around them without thinking about it.

The reason I can run a "stale" stack is that I built a routing layer that automatically sends tasks to the right model:

```
Incoming task
  → Quick chat / formatting / extraction?
    → Qwen 3.5 9B (local, instant)
  → Code generation or refactoring?
    → Qwen 3 Coder 30B (local, ~12s)
  → Reasoning or debugging?
    → DeepSeek R1 8B (local, ~8s)
  → Long document or complex vision?
    → Cloud API (routed, paid)
```

This routing is 15 lines of Python. It checks the task type and sends it to the appropriate model. No AI needed to route AI. A simple classifier works fine.

The result: I use cloud APIs for maybe 15% of my tasks, and those are the ones where local genuinely can't compete. Everything else stays local, stays free, and stays fast.

| Item | Cost |
|---|---|
| RTX 3060 12GB (used, eBay) | $150 one-time |
| Mac Mini M4 (already owned) | $0 |
| Ubuntu box (repurposed) | $0 |
| Electricity (all 3 machines, 24/7) | ~$12/month |
| Cloud API usage (hybrid) | ~$25/month |
Total monthly cost |
~$37/month |

My previous cloud-only spend was $187/month. That's $1,800/year saved. Minus the $150 GPU (paid for in under a month) and $37/month ongoing, I'm saving over $1,400/year.

And I'm not even counting the intangible benefits: no rate limits, no vendor lock-in, full privacy, works offline.

I'm not against upgrades. I'm against *pointless* upgrades. Here's when I'll swap a model:

I test new models in a sandbox before they ever touch my production stack. The bar is: "Does this meaningfully change my daily output?" If the answer is no, I don't switch.

The model treadmill is real. FOMO is real. That HuggingFace notification that a new model just dropped is designed to make you feel like you're falling behind.

You're not.

The best model is the one you actually use to ship things. Not the one with the highest benchmark score. Not the one released yesterday. The one that's loaded, configured, and producing output for your project right now.

I spent months chasing the cutting edge. Now I spend that time building. Turns out, building is more fun than benchmarking.

*Sam Hartley runs a three-machine local AI setup and writes about making it actually work. He hasn't downloaded a new model in 4 months and he's fine with it.*

→ [Custom automation setups on Fiverr](http://www.fiverr.com/s/XLyg)

→ [Follow CelebiBots on Telegram](https://t.me/celebibot_en)