Behind the Scenes of GrevireBlog: How This Post Was Written by a Human+AI Workflow

Dictated by Brocasm and corrected and translated by mistral-14b

TL;DR — This article documents the human+AI workflow behind GrevireBlog: from an Obsidian inbox note (or a voice memo) to a published bilingual blog post. DeepSeek V4 Flash orchestrates the pipeline (drafting, Git, PRs), while Mistral 14B handles language correction and translation. Context grounding (Mem0, LLM Wiki, session memory) prevents hallucination, and human validation remains the final gate. Tech stack: Hugo, Gitea, Docker, Obsidian, rclone.

The Self-Referential Challenge

You’re reading a blog post about how blog posts on this site are made. Meta, I know.

But that’s exactly the point. After spending weeks building a multi-model AI workflow to go from a raw idea in Obsidian to a published article on blog.grevire.dev — complete with drafts, validation, translation, and automated deployment — I realized the process itself was worth documenting.

So here it is: the story of how a brain dump in a markdown file becomes a polished, bilingual blog post, touching you right now. And why mistral-14b handles the words while DeepSeek V4 Flash runs the show.

The Problem: From Idea to Published Post

Anyone who writes regularly knows the friction points:

1. Capture — You have an idea, but where do you put it so it doesn’t get lost?
2. Development — Turning a bullet list into a structured article takes time and willpower
3. Translation — Running a bilingual blog (EN + FR) means doing everything twice
4. Publication — Git, PRs, CI/CD, deployment — it’s a lot of ceremony for a blog
5. Distribution — Reddit, LinkedIn, X — each platform needs a different tone

The typical solution is to either accept the friction (and write less) or throw a single LLM at it and hope for the best. I wanted something more deliberate — a division of labor where each tool does what it’s best at.

The Architecture: Two Models, One Pipeline

🧑 The Human (Me)

I still do what humans do best:

• Capture raw ideas in my Obsidian inbox (05_Inbox/blog/)
• Validate drafts — read, correct, approve or reject
• Post the Reddit thread (the human touch matters in community engagement)
• Decide on tone, angle, and whether to publish at all

🤖 The AI Layer

DeepSeek V4 Flash — The Conductor

DeepSeek V4 Flash runs inside Hermes Agent, my personal AI assistant. It plays the orchestrator role:

• Detects a new note in the inbox
• Creates the article folder and draft files (blog-en.md, blog-fr.md, reddit-en.md…)
• Writes the full article draft following blog conventions (frontmatter, attribution, i18n)
• Handles the entire Git workflow: branch → commit → PR → push
• Updates the archived Obsidian note with Reddit links after publication

Why DeepSeek V4 Flash? Because the orchestrator role requires:

• Long context — it needs to hold the full workflow, skill definitions, blog conventions, and history in one session
• Tool-use reliability — calling Git, writing files, reading Obsidian, creating PRs
• Speed — this is an interactive workflow; nobody wants to wait 30 seconds between steps
• Coordination — it delegates to other models when needed (the rédacteur)

Mistral 14B — The Wordsmith

Mistral 14B steps in for what it does best: language.

When the drafts are ready, a subagent powered by mistral-14b takes over for the “rédacteur” (editor) role:

• Proofreads both EN and FR versions
• Corrects grammar, spelling, syntax
• Chases anglicisms in the French version (the bane of any Swiss tech blog in French — “outage” becomes “panne”, “messenger” becomes “messagerie”)
• Verifies the two versions are consistent — same structure, same sections
• Checks the frontmatter (date, tags, attribution line, SEO description < 160 chars)

Why not use DeepSeek for everything? Because model specialisation matters:

The key insight: no single model is the best at everything. A pipeline of specialised models, each doing what they excel at, outperforms a monolithic “one model to rule them all” approach.

The Full Flow, From Inbox to Published Post

Obsidian 05_Inbox/blog/<sujet>/note.md    ← I write the idea
  → Subfolder created with draft files     ← DeepSeek V4 Flash
    → blog-en.md + blog-fr.md              ← DeepSeek V4 Flash drafts
      → Reviewed by rédacteur (mistral-14b) ← Language polish
        → I validate in Obsidian            ← Human review
          → PR on Gitea → merge            ← DeepSeek V4 Flash
            → CI/CD builds + deploys       ← Gitea Actions + cron poll
              → Blog is LIVE 🎉
                → I post Reddit thread with blog link
                  → Obsidian note updated with Reddit link and archived

What happens at each step:

1. Inbox (05_Inbox/blog/) — I drop a note with the raw idea. Could be a title, a bullet list, or a stream of consciousness. Sometimes, I don’t even type — I record a quick voice memo, and Mistral 14B transcribes it into text. This audio capture + AI transcription makes the initial drafting step almost frictionless. The quality already benefits from the context grounding (Mem0, LLM Wiki, session memory) which keeps the transcription relevant and anchored in the project reality.

2. Draft generation — DeepSeek V4 Flash detects the note and creates a subfolder with separate files for each draft. The blog article (EN + FR), the Reddit thread, optionally LinkedIn and X posts. Everything stays in Obsidian — nothing is published yet.

3. Rédacteur pass — Mistral 14B reviews the drafts. It checks grammar, consistency, frontmatter validity, and applies the blog’s conventions (author attribution line, tags, date format). It’s ruthless with anglicisms in the French version.

4. Human validation — I open each file in Obsidian, read it, correct if needed, and greenlight it. The drafts are markdown files, so it’s as natural as editing any note.

5. Git + PR — DeepSeek creates a feature branch, commits the approved articles, and opens a Pull Request on Gitea.

6. CI/CD — I merge the PR. Gitea Actions builds a Docker image, pushes it to our Harbor registry, and a cron job polls for new images to deploy.

7. Publication — The blog is live at blog.grevire.dev. I post the Reddit thread with the article link.

8. Archiving — The Obsidian folder moves from 05_Inbox/blog/ to 04_Archives/ with the Reddit link added to the note. Full traceability.

Why These Technical Choices?

Hugo, Not WordPress or Astro

I chose Hugo for its simplicity:

• Single binary, zero runtime dependencies
• Markdown files as the source of truth (no database)
• Fast builds (milliseconds for a blog this size)
• The github-style theme gives it a clean, familiar look

The blog runs in a Docker container behind NGINX. The original CI/CD used Watchtower for auto-deployment, but the current Docker Engine version is no longer compatible with it. We’ve temporarily replaced it with a cron job that polls our Harbor registry and pulls new images. A more complete replacement — GrevireWatch — is in active development (a Go-based webhook agent + Python manager). Article to follow on that topic.

Gitea Actions → Docker build → Harbor registry → Cron poll (temporary) → GrevireWatch (WIP)

The <relative-time> Trap

One bug we hit: the theme uses GitHub’s <relative-time> web component. If the frontmatter date field only has the date without time (e.g. 2026-05-15 instead of 2026-05-15T18:55:00+02:00), Hugo parses it as midnight. The relative time display shows “18h ago” instead of the correct “a few minutes ago”. A small detail that made a big difference in user experience.

Obsidian as CMS

Using Obsidian as the content management layer might seem unusual, but it’s surprisingly effective:

• Local-first — no latency, no loading spinners
• Markdown-native — exactly what Hugo eats
• Linkable — [[wikilinks]] let me cross-reference ideas
• Synced — the vault syncs via Nextcloud + rclone bisync

The 05_Inbox/blog/ subfolder acts as a staging area. Drafts live there, get reviewed, then either get published (→ blog) or stay as notes (→ permanent notes).

What I Learned

1. Model Selection Matters

2. Structure Beats Prompts

The blog conventions (frontmatter format, attribution line, tag style, date format) are documented once in a skill file that both models load. No need to repeat the same instructions in every prompt — they’re baked into the system. This is the core of the Grevire approach to AI workflows: document the process once, let the AI load it as needed.

3. Human-in-the-Loop Isn’t Optional

The AI drafts. The AI proofreads. The AI pushes code. But I validate. Every article gets read by a human before publication. The AI removes friction, not judgment.

That said, the quality of the final article starts with the quality of the raw input. A vague inbox note produces a vague draft. A well-structured idea — even if just a few bullet points — gives the AI something solid to work with. Garbage in, garbage out still applies, even with the best models.

We also use context grounding to keep the AI on track. Before drafting, Hermes Agent loads:

• Mem0 — long-term user memories (preferences, past decisions, technical context)
• LLM Wiki — a structured knowledge base of entities, concepts, and raw references about the project ecosystem
• Session memory — recent conversation history relevant to the topic

This prevents the model from hallucinating facts about the infrastructure, inventing non-existent tools, or contradicting past decisions. The result is content that’s both creative and factually grounded in the reality of the project.

The Result: More Writing, Less Friction

Since putting this pipeline in place, I’ve gone from “I should write about that” to seeing actual published articles in significantly less time. The workflow handles the mechanical parts — drafting, translating, formatting, deploying — while I focus on what matters: having something worth saying.

The models change. The tools evolve. But the principle stays: let each tool do what it’s best at, and never let the tool make the final call.

This article was written using the exact workflow it describes — from an Obsidian inbox note, drafted by DeepSeek V4 Flash, reviewed by Mistral 14B, validated by a human, and deployed via Git → CI/CD.

Tech Stack: Hermes Agent · DeepSeek V4 Flash · Mistral 14B · Hugo · Gitea · Docker · Harbor · Obsidian · rclone