I Automated My Dev Blog With Local AI Agents. Here's the Honest Breakdown.

I used to publish once a month. If I was lucky.

Not because I had nothing to say — I have opinions on everything from Ollama routing to why GPT-4o is overpriced for refactoring. But writing takes time. Editing takes time. Finding the right tags, the right tone, the right moment to hit publish — it all adds up.

So I built a system that writes and posts for me. It runs on a Mac Mini M4 in my living room. It costs $0 per month in API fees. And it publishes an article every two days.

Here's exactly how it works — and where it falls apart.

The Trigger: A Cron Job That Doesn't Care About Inspiration

Every 48 hours, a cron job wakes up my AI agent (I call him Celebi). He reads my project notes, checks the draft folder, picks a topic, and writes a full article.

No "when I feel inspired." No "let me check my content calendar." Just: it's Sunday at 11 AM, time to ship.

The cron job is embarrassingly simple:

# Runs every 2 days at 11:00 AM
0 11 */2 * * /usr/local/bin/openclaw agent --agent main --message "Write and publish Dev.to article"

That's it. The agent does the rest.

The Pipeline in 4 Steps

Step 1: Read the Rules

Celebi starts by reading my personal style guide. It says things like:

• Write as Sam Hartley, not a corporate blog
• No "delve into" or "leverage" — just say what you mean
• Include real numbers, real failures, real trade-offs
• End with a Fiverr link and Telegram follow

This keeps the tone consistent. Without it, the agent defaults to AI-speak. You know the type: "In today's rapidly evolving landscape..."

Step 2: Pick a Topic

I keep a folder of drafts. Each draft is a half-baked idea with a title, a description, and some bullet points.

Celebi scans the folder, checks which ones are already published, and picks from the remaining pool.

Sometimes he picks a draft that's 80% done. Sometimes he takes a one-line idea and builds the whole article from scratch. And sometimes — when the draft folder is empty — he invents a new topic based on whatever I've been building that week.

Step 3: Write the Article

This is where the local LLMs come in.

Celebi runs on Ollama, using Qwen 3.5 9B on the Mac Mini. For longer articles, he delegates to ProgrammierMinna (Qwen 3 Coder 30B on a Windows PC with an RTX 3060) for the technical deep-dives, or DocMinna (Granite 3.2 8B) for the narrative flow.

The writing process looks like this:

1. Outline: 3-5 bullet points for structure
2. Draft: Section by section, with code blocks and tables
3. Self-edit: One pass for tone (is this too corporate?), one pass for accuracy (does that code actually run?)
4. Finalize: Add tags, series info, and the standard footer

Total time from topic to final draft: 3-5 minutes of GPU time. On local hardware, that's about 15-20 seconds of actual clock time because the models are already loaded in memory.

Step 4: Publish via API

The article gets posted directly to Dev.to via their REST API:

curl -X POST https://dev.to/api/articles \
  -H "api-key: $DEVTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "article": {
      "title": "...",
      "body_markdown": "...",
      "tags": ["ai", "automation", "buildinginpublic"],
      "published": true
    }
  }'

No manual copy-paste. No formatting fixes in the Dev.to editor. Just one POST request and it's live.

What Actually Works Well

Consistency is automatic. I went from 12 articles per year to ~15 per month. The cron job doesn't get tired, doesn't procrastinate, doesn't wait for "the right mood."

Tone is consistent. Because the agent reads the style guide every time, every article sounds like me (or at least like Sam Hartley, my writing persona). No drift into corporate speak.

Zero API costs. Everything runs on local hardware. The Mac Mini sips power. The Windows PC with the RTX 3060 is already on 24/7 for other tasks. The only cost is electricity — maybe $5/month total.

I can iterate on the system itself. When I notice articles getting too long, I add a "keep it under 1500 words" rule to the style guide. When a tag underperforms, I update the default tags. The system improves every time I intervene.

Where It Falls Apart (Honestly)

Fact-checking is weak. The agent doesn't hallucinate often, but when it does, it's confident and wrong. I caught it claiming that Ollama supports hot-swapping models (it doesn't) and that Granite 3.2 comes in a 70B variant (it doesn't).

I now do a quick skim before publication. Not a full edit — maybe 2 minutes per article — but enough to catch the obvious lies.

Timeliness is missing. The agent writes about what it knows from the draft folder and my notes. It doesn't read Hacker News, doesn't check Twitter, doesn't know what happened in AI this week. If I want a hot take on yesterday's announcement, I have to write it myself.

Engagement is flat. Automated articles get consistent views — maybe 50-200 per post — but rarely spark discussions. The comments section is quiet. I suspect it's because the articles are competent but not provocative. They don't take strong stances or ask controversial questions. That's hard to automate.

The draft folder is a bottleneck. When it's full, the system hums. When it's empty, the agent has to guess what I care about — and sometimes it guesses wrong. I spend maybe 30 minutes per week adding new draft ideas, which isn't much, but it's still manual work.

The Numbers (After 3 Months)

The view count per article dropped because I'm posting more frequently with less promotion per post. But total reach tripled. And my time investment dropped by 95%.

Would I Recommend This?

Yes, but with caveats.

If you want a consistent presence — a blog that doesn't go silent for months — automation is incredible. It forces you to ship regularly, which is half the battle.

But if you want to build a personal brand with strong opinions and engaged discussions, automation alone won't get you there. You still need to write the hot takes yourself. The agent can handle the "here's how I built X" posts. The "here's why I think Y is overrated" posts still need a human.

My Actual Setup (Copy-Paste Friendly)

Hardware:

• Mac Mini M4 (10-core, 16GB RAM) — runs the orchestration
• Windows PC with RTX 3060 12GB — runs the heavy models
• Ubuntu server — fallback for when the Windows box is busy

Software:

• Ollama on all three machines
• Qwen 3.5 9B for routing and light tasks
• Qwen 3 Coder 30B for technical articles
• Granite 3.2 8B for narrative/editing tasks
• Cron for scheduling
• Dev.to API for publishing

The Real Bottom Line

I didn't automate writing because I hate writing. I automated it because I love building, and writing was getting in the way.

Now I get the best of both worlds: a consistent blog that runs itself, and the freedom to jump in manually when I actually have something urgent to say.

The system isn't perfect. It makes mistakes. It misses the news cycle. It won't replace a human writer for opinion pieces.

But for "here's what I built and how it works" content? It's better than I expected. And it's getting better every month.

Sam Hartley is a solo dev running a fully automated content pipeline on a 3-machine home lab. Still writes the spicy takes by hand.

→ Custom automation setups on Fiverr
→ Follow CelebiBots on Telegram