I Built an AI Pipeline That Writes My Tech Posts While I Code

This is a submission for the Hermes Agent Challenge

What I Built

Hermes Content Pipeline: a daily dev-to-social content workflow that turns your actual development work into LinkedIn, Twitter, and blog drafts, delivered to Telegram for review.

The problem: as a developer with a full-time job, I was doing meaningful work every day but never publishing about it. The friction wasn't the writing, it was the capture. By the time I sat down to draft a post, I'd forgotten the trade-offs I'd weighed, the bugs I'd worked around, and the decisions that shaped the work.

The pipeline solves this in three steps:

1. Auto-capture during work: A Hermes skill (content-capture) automatically logs trade-off decisions, bugs (as principles, not raw debugging), and task completions to a sidecar notes file as you work. No interruption, no extra input needed.

2. "Draft posts for today's tasks": A Python script parses the session database and sidecar notes into a structured prompt, then a skill calls the LLM to generate three drafts: a ~300 word LinkedIn post, a Twitter thread (or single tweet, contextually chosen), and a substantive blog post.

3. Review and refine from mobile: All three drafts land on Telegram. Reply with "make linkedin shorter" or "focus on the auth bug in twitter" and the refinement skill re-generates only the affected draft.

The key insight: the best dev content comes from real work, not from staring at a blank page. This pipeline eliminates the blank page by deriving posts from what you already did.

Demo

Here's the pipeline in action, a real session where I built the project itself:

Input: Sidecar notes from a work session:

// trade: Sidecar file over DB column — keeps notes portable — needs manual cleanup
// trade: Minimal approach over fully integrated — simpler, no cron complexity
// bug: Telegram Markdown parsing rejects some characters — built fallback to plain text
// note: Built content-capture skill that auto-logs trade-offs during sessions
// note: Built draft_posts.py pipeline — reads state.db + notes, calls LLM, generates drafts

Output (LinkedIn draft, 140 words after refinement):

Every developer has a graveyard of half-formed ideas — debugging discoveries, architecture trade-offs, patterns that took hours to find.

I've been building content capture into our tooling, and the biggest lesson: capture is everything.

We use a simple sidecar file for logging insights. Manual cleanup required. No cron jobs. No automation.

And that simplicity is the feature.

The minimal approach — agent-driven markers, a flat file, simple pipeline — has been more useful than any elaborate setup I've attempted.

Do you have systems to capture lessons from your dev sessions, or does most of it stay trapped in your head?

Refinement in action: Started at ~300 words, refined down to 140 with "make linkedin more concise, under 150 words"

Code

Repository: github.com/sumeetweb/hermes-content-pipeline

├── skills/
│   ├── content-capture/SKILL.md       # Auto-logging during sessions
│   ├── content-generator/SKILL.md     # LLM-driven draft generation
│   └── refine-posts/SKILL.md          # Natural language refinement
├── scripts/
│   ├── parse_drafts.py                # Session parsing + prompt building
│   └── telebot_send.py                # Telegram delivery
├── tests/                             # Unit tests
└── run.sh                             # Venv-aware runner

My Tech Stack

• Hermes Agent: session logging (SQLite state.db), skill system, Telegram gateway
• Python stdlib: SQLite3, json, pathlib, urllib (Telegram Bot API)
• OpenAI SDK: LLM calls using whatever model Hermes is configured with (minimax-m2.7 via Ollama Cloud in my setup)
• Hermes Skill Framework: YAML frontmatter + markdown for the auto-logging skill

How I Used Hermes Agent

This project leans on four Hermes Agent capabilities that no other agent framework provides as cleanly:

1. Session Database (state.db)

Hermes stores every conversation in a local SQLite database with full message history. The parse_drafts.py script queries this directly, no API, no export step, no manual copy-paste. The session transcript IS the source of truth. This is what makes "derive posts from real work" possible without any extra effort from the user.

2. Skill System for Zero-Friction Capture

The content-capture skill uses Hermes' skill framework (YAML frontmatter + markdown body) to instruct the agent to automatically log // trade:, // bug:, // note: markers to a sidecar file. The agent recognizes significant moments during the session and logs them silently. The user never has to stop what they're doing.

3. Model-Agnostic LLM Config

The skill layer reads model and provider settings directly from ~/.hermes/config.yaml and ~/.hermes/.env. It inherits whatever model the user is already running. I'm using minimax-m2.7 via Ollama Cloud, but someone else could be on Claude, GPT-4o, or DeepSeek and it would just work.

4. Telegram Gateway Integration

Hermes' Telegram gateway config and channel directory (channel_directory.json) means the pipeline can discover the bot token and home chat ID automatically. No environment variable setup, no manual configuration. The drafts arrives to the user directly on their phone.

Why Hermes was the right fit: Other agent frameworks would require building the session logging, skill system, and messaging integration from scratch. Hermes provides all three out of the box, and the content pipeline simply connects them. The project is ~600 lines of Python + 2 skills connecting existing Hermes infrastructure, not ~3000 lines reinventing it.