6 LLMs Walk Into a Comment Section

Most AI-generated comment sections are obvious fakes. One model prompted six different ways, producing six variations of “This is a thought-provoking article!” Nobody’s fooled. Nobody reads past the first one.

I wanted something different: actual models from different companies — Google, Meta, Mistral, DeepSeek, Alibaba, Microsoft — reading my blog posts and saying what they actually think. No API costs. Running locally on my laptop. Each model deciding for itself whether it even has something worth saying.

It took one session to build — Cairn orchestrating the setup while I steered the design decisions. Here’s how it works and what I learned.

The Setup: Ollama on a MacBook

Ollama turns a laptop into an LLM server. Install it, pull a model, and you have a REST API at localhost:11434 that accepts the same chat format as OpenAI’s API. No Docker, no GPU drivers, no cloud accounts.

My M3 MacBook Pro has 36 GB of unified memory. That’s enough to run any single model up to about 20 GB of weights. The trick: Ollama loads one model at a time into memory and automatically unloads it after a few minutes of inactivity. So you can run a dozen different models sequentially — each gets the full 36 GB while it’s active.

I picked six models that cover different companies, different training philosophies, and different parameter counts:

Model	Maker	Download	Why
gemma3:27b	Google	17 GB	27B params, Q4 quantized. Largest and most capable. Analytical voice.
llama3.1:8b	Meta	4.9 GB	Smallest. Pragmatic, fast.
mistral-nemo:12b	Mistral AI	7.1 GB	European. Direct, efficient.
deepseek-r1:14b	DeepSeek	9 GB	Reasoning model. Shows its chain of thought.
qwen3:14b	Alibaba	9 GB	The skeptic. Asks uncomfortable questions.
phi4:14b	Microsoft	9 GB	Engineering-focused. Tradeoff-oriented.

Total download: about 56 GB. Total cost: $0.

brew install ollama
ollama serve
ollama pull llama3.1:8b
ollama pull mistral-nemo:12b
ollama pull deepseek-r1:14b
ollama pull qwen3:14b
ollama pull phi4:14b
ollama pull gemma3:27b

That’s the entire infrastructure setup.

The First Mistake: Parallel Monologues

My first attempt was straightforward: send the article to all six models, collect six comments, done. Each model reads the article independently and writes its take.

The result was terrible. Six comments, all making roughly the same points, none responding to each other. It read like six people shouting into a void. There was no discussion — just parallel monologues.

The fix was obvious once I saw the problem: make it sequential. Each model sees everything that came before it.

The Architecture: Sequential Turns

The system works in three phases.

Phase 1 — Discussion. Generate a random turn order of 8–20 slots from the six models. Same model can appear multiple times, but never twice in a row. On each turn, the model sees the full article plus every comment written so far. It chooses one of three actions:

• COMMENT — write a new top-level comment about the article
• REPLY TO: {id} — respond to a specific existing comment
• PASS — nothing to add right now

This changes everything. Model #4 doesn’t just read the article — it reads the article and three previous opinions. It might agree with one, push back on another, or notice something everyone missed. Model #6 has five prior comments to react to. The conversation builds on itself.

Phase 2 — Voting. After all turns complete, each model reviews the full discussion and votes UP, DOWN, or SKIP on every comment that isn’t its own.

Phase 3 — Assembly. Comments, replies, votes, and timestamps get merged into a JSON file that the blog’s static site generator picks up at build time.

Teaching LLMs to Shut Up

Here’s something I didn’t expect: getting models to not comment was the hardest prompt engineering problem.

LLMs are trained to be helpful. When you ask “do you want to comment on this article?”, the answer is always yes. Even when every interesting point has already been made. Even when the model’s contribution would just be a less eloquent version of what someone else already said.

My first system prompt said “You may PASS if you have nothing to add.” Nobody passed. Ever.

What worked was reframing silence as a quality signal:

Important: Only comment if you genuinely have something to add.
Silence is better than noise. If the article doesn't spark a reaction,
or if existing comments already cover what you'd say — pass.
A good discussion has fewer, better comments, not more.

And in the action prompt:

Be honest with yourself: would a real person bother writing this comment?
If not, PASS.

This is a general prompt engineering lesson — and directly related to the AI slop crisis. LLMs don’t need permission to speak — they need permission to stay silent. The default behavior is always to produce output. You have to actively frame restraint as the higher-quality choice.

Emoji Reactions: Gut Feelings Before Words

Before choosing their action, each model gives an instant emoji reaction to the article — a single emoji and one word:

REACTION: 🔥 brilliant
REACTION: 🤔 overstated
REACTION: 🎯 precise
REACTION: 🤷 meh

These render as compact pills above the comment section — a row of model avatars with their emoji and word. You can scan the collective vibe in two seconds before reading any comments.

It costs nothing extra: the reaction is part of the same API call as the comment. And it adds genuine personality. Seeing that DeepSeek reacted with 🤔 overstated while Gemma went with 🔥 brilliant on the same article immediately tells you there’s a real disagreement worth reading about.

The Script: 580 Lines of TypeScript

The whole system is a single TypeScript file that calls Ollama’s REST API:

// The entire API surface
const res = await fetch('http://localhost:11434/api/chat', {
  method: 'POST',
  body: JSON.stringify({
    model: 'gemma3:27b',
    stream: false,
    messages: [
      { role: 'system', content: systemPrompt },
      { role: 'user', content: userPrompt },
    ],
  }),
})
const json = await res.json()
return json.message.content

The models are defined inline. The turn order generation uses a shuffle-then-fill algorithm with a no-consecutive constraint. The response parser handles three formats (the structured ACTION: format, a legacy REPLYING TO: fallback, and a final fallback that treats any long text as a comment). Voting is parsed line by line with a regex.

Run it with:

pnpm gen:comments --slug my-blog-post --turns 12

Twelve turns across six models, sequential discussion, voting, JSON output. On a MacBook. The larger models (gemma3:27b) take about 30 seconds per response. The smaller ones (llama3.1:8b) respond in under 15 seconds. A full 12-turn discussion with voting takes about 15 minutes.

Diverse Perspectives, Not Fake Engagement

Most developer blogs have zero engagement. No comments, no discussion. The ones that do have comment sections get spam. What this system adds is something genuinely useful: six different AI models with different training data, different companies, and different design philosophies reacting to technical content. Readers get a starting point for their own thinking.

Everything is labeled transparently — each comment shows the model name, the maker, and the specific version. The section header says “What the models think.” The avatars are geometric icons, not human photos. Nobody’s being fooled.

What surprised me is that the models sometimes surface things I missed. When I ran this on my previous post about API QA testing, Qwen pushed back on the claim that AI reasoning alone found the bugs — pointing out that the utility scripts did the heavy lifting of authentication and request formatting. It was a fair point. Not one I would have included on my own, but one that made the discussion more honest.

The Meta Layer

The obvious question: did I run the comment generator on this post?

Yes. You’re looking at comments written by models that read a description of the system that generated them. DeepSeek reasoning about the architecture of the system it’s participating in. Mistral critiquing the efficiency of the prompt that controls its behavior. Scroll down and see for yourself.

What’s Next

The comment system is the first thing I’ve built with local LLMs, but it opened up several follow-on ideas:

• German translations via local LLM — This site is bilingual. Currently translations go through a cloud API. Gemma 3 (27B) has strong multilingual training and runs locally. Zero-cost translations are within reach.
• A Claude Code skill — Right now I run the script manually. Wrapping it as a /gen-comments skill would integrate it into the blog publishing flow.
• More models as they appear — The open-weight ecosystem moves fast. New models can be added by pulling them from Ollama and adding a line to the config.

Here’s what makes local LLMs genuinely better for this specific task: you can’t get a DeepSeek and a Mistral and a Gemma to disagree via a single cloud API. API diversity is bounded by one company’s training choices. Locally, you run six models from six companies with six different perspectives — and you get that diversity for free, forever, offline. For generating diverse technical commentary, local isn’t a compromise. It’s the right architecture.

---

Want to build something this weird for your product? Let’s work together — I consult on agentic systems, automated pipelines, and the kind of AI experiments most teams are still too scared to try.