The Model That Aced Olympiad Math Can't Write a Tweeteric

Last time, the 4 GB card you already own turned out to reason like a giant: VibeThinker-3B, a 3-billion-parameter specialist, solved competition math that models twice its size could not — entirely on a modest laptop GPU. That was a genuinely surprising result, and it left an obvious, almost lazy follow-up question hanging in the air.

If a 3B model on a gaming laptop is clever enough to crack an olympiad problem, surely it can knock out a short story or a tweet?

No. It cannot. And the way it fails is far more interesting than a simple "it's not very good," because it tells you something true about all of these small models — and about which one you should actually reach for when you want words instead of answers.

The test it should have passed

Same laptop, same spirit as the rest of the series: give the model a job and judge the result honestly. The jobs here are the easiest imaginable — the sort of thing you would dash off without thinking:

• Write a 120-word short story about a lighthouse keeper who finds a message in a bottle.
• Write a warm, 4-sentence email politely declining a meeting and proposing to handle it async.
• Write a 4-line poem about autumn rain.

VibeThinker got the poem. On the other two, it produced nothing at all — not a bad story, not a wrong story, no story. It ran for 42 seconds, generated over eight thousand characters, and never once emitted the piece it was asked for.

Where did all that effort go? Into counting. Here is the shape of what it did, lightly trimmed:

Copy We must generate exactly 120 words, counting each word separated by spaces...
First draft: "The lighthouse keeper, Elara, tended her beacon each midnight.
One stormy night a wooden bottle appeared on the rocks..."
Now count words. Let's count manually:
The(1) lighthouse(2) keeper,(3) Elara,(4) tended(5) her(6) beacon(7) each(8)
midnight.(9) One(10) stormy(11) night(12) a(13) wooden(14) bottle(15)...

It wrote a perfectly serviceable draft — "its beam cutting through the fog like a whispered hope" is a nice line — and then buried it under an obsessive, self-appointed audit of the word count, recounting from the top, second-guessing whether punctuation counts, and running clean out of budget mid-tally. The 4-sentence email died the same way, deliberating about whether a greeting counts as a sentence until the tokens ran out.

The tell is what happens when you remove the number. Ask it for "a short atmospheric story about a lighthouse keeper" — no count — and it finishes in 16 seconds with a genuinely lovely 385-word piece. So the prose is not the problem. The constraint is.

Why the training that won the math lost the tweet

This is the whole point, so it is worth saying plainly. VibeThinker is trained for verifiable reasoning — problems where an answer can be mechanically checked. That training instilled one deep reflex: when there is a checkable target, work it relentlessly until it is provably satisfied. On an AIME problem, that reflex is a superpower.

Now hand that same reflex a writing task with a number in it. It does not see "write me something nice, roughly this long." It sees a verifiable target — exactly 120 words — and does the only thing it knows how to do with a verifiable target: reason about it, exhaustively, checking and rechecking. It optimises the one trivial, checkable part of the request and never delivers the part you actually wanted. The scalpel that so precisely dissects a maths problem is trying to paint a watercolour, and it keeps stopping to measure the brush.

Its own model card warned us, in so many words: this is a specialist; for open-domain work, use a general model. Last post that was an abstract caveat. This is what it looks like in practice — the model is not bad at prose, it is mis-aimed at prose.

So who can write? The boring models

The fix is not a cleverer model. It is a less clever one — a plain instruct model with no reasoning theatrics. I pulled two that fit the 4 GB card easily and ran the identical battery:

• gemma2:2b — Google's Gemma 2, 2 billion parameters, ~2 GB on disk.
• qwen2.5:3b — Qwen2.5 3B Instruct, the general-purpose sibling of the qwen2.5-coder:3b we use for code.

Both instruct models delivered every piece, in seconds, with no thinking detour at all. The reasoning model spent 42 seconds failing to produce a story; the 2B model produced one in eight. And the prose was not just present — it was good. Gemma's lighthouse story opened with "The salt spray stung Thomas's weathered face" and turned on a real hook — "Find the siren's song, she holds the key." For a 2-billion-parameter model that fits in the change drawer of your VRAM, that is startling.

Across the battery, gemma2:2b wrote the nicest English prose — the most vivid story, the most natural-sounding email, the best poem imagery — and it did it from the smallest footprint of any model in this series. Google clearly tuned its little models hard for exactly this. qwen2.5:3b was a close, dependable second and the better all-rounder if the model also has to answer questions or reason a little.

One honest caveat that applies to all of these small models, not just the reasoning one: none of them nails an exact count. Gemma's "120-word" story came back at 136 words; Qwen's at 95. The difference between them and VibeThinker is not precision — it is that they hand you a usable draft to trim, instead of an empty tally. The practical rule writes itself: never give a small model an exact number. Ask for "around 120 words" and trim it yourself.

The language twist

Gemma wins English. But there is a catch that matters if you are not writing in English, and it flips the ranking.

Gemma 2 is English-first. Ask it for a Chinese tweet and it produces something fluent and grammatically correct — but subtly translated, reading like polished textbook Chinese rather than something a person would actually post. qwen2.5:3b, from Alibaba and trained heavily on Chinese, reads like a native did write it. Asked for a relaxed weekend-coffee tweet, it reached for real internet register — 窝在家里 (curl up at home), the trendy clipped 暖咖 for a warm coffee, a playful hashtag, even the native ～ trailing tone. For a shop opening it opened with the correct idiom, 开业大吉. A tech tweet called an old laptop 老本子 — exactly the slang a Chinese tech user would type.

The lesson is not "Qwen is better." It is that "good at writing" is not a single axis. Gemma is the better English stylist; Qwen is the better Chinese one — because writing quality is downstream of what a model was trained on, and these two were raised on different languages. The same trap as the reasoning model, one level up: match the tool to the job, and here the job includes the language.

Match the model to the job

Step back and the whole small-model series keeps arriving at the same place. Capability is not one number you can rank models by; it is a profile. A 4 GB laptop can now cover an astonishing spread of work — but not with one model. With several, each a specialist, and not one of them the "smartest" in the room:

VibeThinker earns its place on that list — for its row. It is a scalpel, and a scalpel is the wrong thing to write a letter with, not a worse thing than a pen. The mistake is expecting the model that aced the maths olympiad to also be the one you hand a tweet. It is the dispatch lesson again, in a new suit: stop asking "which small model is best," and start asking "best at what."

Reproduce it yourself

Both writers are one command each, and both sit comfortably on a 4 GB GPU:

Copy ollama pull gemma2:2b     # ~2 GB — best English prose
ollama pull qwen2.5:3b    # ~2 GB — best Chinese, best all-rounder

Then hand one a writing task — and mind the trap that broke the reasoning model:

Copy # Don't do this to a reasoning model — the exact count sends it counting forever:
#   "Write a 120-word story ..."
# Do this instead, with any instruct model:
curl -s http://localhost:11434/api/chat -d '{
  "model": "gemma2:2b",
  "messages": [{"role":"user","content":"Write a short atmospheric story about a lighthouse keeper who finds a message in a bottle."}],
  "stream": false
}' | python3 -c 'import json,sys; print(json.load(sys.stdin)["message"]["content"])'

If you do want to feel the failure for yourself, run the same 120-word prompt against vibethinker3b and watch it disappear into an arithmetic trance. It is a strangely instructive thing to see: a model too smart, in exactly the wrong way, for the simplest job on the list.

The laptop now holds four little specialists — a coder, a reasoner, an English writer, a Chinese writer — none of them a generalist, all of them fast and free. Which raises the question this series keeps circling back to: can a small model be trusted to pick the right specialist for an incoming request on its own, and route to it, without a human deciding first?