The Blog Engine We Built to Document Our Own Work
Joe Plowman · Sun Mar 08 2026 00:00:00 GMT+0000 (Coordinated Universal Time) · 8 min read
The Blog Engine We Built to Document Our Own Work
URL slug: ai-blog-engine-document-operations Meta description: How we built an automated blog pipeline using Trello, AI agents, and a structured review workflow — producing 3 posts per week for under $2 in API costs. Primary keyword: AI blog engine Long-tail keywords: automated content pipeline AI, AI agent content production, document operations blog workflow
Published: plowman.ai/blog Category: AI Operations Read time: ~8 min
We've been building a 15-agent AI operation for several months. Most of the operational detail — what we built, what broke, what we learned — has been living inside our Trello board and memory files, accessible to the agents but invisible to anyone outside.
That's a problem for two reasons.
First, the work we're doing is genuinely useful to other builders. Not as inspiration or as proof that AI is exciting — as a practical reference. We're solving the same problems anyone running a serious multi-agent operation hits: measurement infrastructure, agent orchestration, model cost management, client onboarding workflows. If we document it as we go, it becomes a resource. If we don't, it evaporates.
Second, the documentation process is itself valuable. Writing up what we built forces clarity about why we built it that way, what the tradeoffs were, and what we'd do differently. It's operational QA in the form of a blog post.
So we built a blog engine. This post documents what it is, how it works, and what it costs to run.
The Problem We Were Solving
There's a specific failure mode we wanted to avoid: the blog that starts with good intentions and dies after four posts because it requires too much manual effort.
The pattern is familiar. Someone decides to start a content operation. They spend a week on the first post, publish it, get some positive response. Second post takes three weeks because they're busy. Third post takes two months. By the fourth post, it's been six months and nobody is reading anymore because the RSS feed went quiet.
The failure isn't usually laziness. It's that content production competes with everything else for the operator's time, and content almost always loses to revenue-generating work.
Our constraint was the same as everyone else's: JP has a board seat, two operating companies, a healthcare marketing client pipeline, and a 15-agent platform to run. The blog will not get sustained attention unless it runs mostly without him.
That means the engine has to do the heavy lifting. JP sets direction. The agents produce. JP reviews and approves. The post publishes.
The Source Material
The blog engine starts with Trello.
Every significant piece of work that runs through our platform flows through the Trello board — tasks assigned, completed, blocked, escalated. The board is the operational record of what's actually happening. It's updated in real time by agents as they work.
At the end of each week, Rip (our Chief of Staff agent) exports a structured summary of the board: what was completed, what's in progress, what's blocked, what's queued for next week. This summary is the raw material for blog content. Everything in the posts is drawn from actual work recorded in the board — not reconstructed from memory.
The advantage of sourcing from Trello is accuracy and specificity. When we write that we installed GTM on a fertility clinic client's website and hit a double-counting issue with GA4, that's in the Trello card. The card has the problem, the resolution, and the timestamp. The blog post is a narrative layer on top of the operational record, not a separate creative exercise.
This distinction matters. The authenticity of practitioner-to-practitioner writing depends on the specifics. Anyone can write "we faced challenges and learned from them." Only someone who actually did the work can write "the form redirect was generating inconsistent URL query strings, which broke the page-load trigger, and we fixed it with a regex match in GTM." The second version is useful. The first is noise.
The Production Workflow
Once Rip has the weekly Trello export, the blog pipeline works as follows.
Step 1 — Rip identifies story candidates. From the completed work, Rip selects two or three items with enough operational detail to be worth a full post. The criteria: something we actually built or solved, with specific decisions and real outcomes. Not "we made progress on X" — not enough detail. "We installed the measurement stack and here's what broke and how we fixed it" — that's a post.
Step 2 — Rip sends the brief to Hormozi. The brief includes the source material (Trello export, relevant memory files), the post template (structure, voice, length, what to include and exclude), and any context needed to write with specificity.
Step 3 — Hormozi writes the drafts. First-person plural voice, practitioner tone, 1,500–2,000 words. Problem → what we built → how it works → results/lessons → what's next. Three posts per cycle, running in parallel where the content allows.
Step 4 — Quality check. Drafts route to a review step before JP sees them. The checklist: voice is right (not AI slop, not marketing copy), specifics are present (not vague claims), no confidential information (no client names, no case details, no credentials), length is in range.
Step 5 — JP approves. JP reads the draft, approves or redlines. Nothing publishes without his sign-off. This is the only step that requires his direct attention, and it's designed to take under five minutes per post — a clean draft that needs no structural revision, just a read-through.
Step 6 — Scout formats and queues. Scout (our content agent) handles CMS formatting, adds the featured image brief, and queues the post in the publishing schedule.
From Trello export to JP-ready draft: approximately 24 hours. From JP approval to published: same day.
The Post Template
The template isn't rigid, but it has a structure that every post follows:
Headline. Specific and operational. "How We Built a Digital Marketing Stack for a Fertility Clinic in 72 Hours" rather than "What We Learned About Digital Marketing." The reader should know exactly what the post is about from the headline alone.
Opening context. Why this work was needed. What problem we were solving. Not a preamble — one or two paragraphs and then into the content.
What we built or did. The actual work. Specific decisions, specific tools, specific configuration. If we installed GTM, we say how we installed it, what tags we configured, and what the GTM trigger logic looks like. If something broke, we say what broke, why it broke, and exactly how we fixed it.
How it works now. Current state. What the system looks like after the work is done. What it produces, what it costs, what we're tracking.
Lessons. What we'd do differently. What we didn't expect. What turned out to matter more than we thought.
What's next. The next step in the same work. This creates continuity across posts — each post connects to the previous one and points toward the next. Readers who find one post will find the thread.
What It Costs to Run
The blog engine has two cost components: AI token spend and time.
Token spend is low. The primary writing agent (Hormozi) runs on Claude Sonnet. Three posts at 1,500–2,000 words each, plus the context loaded to write them, comes to roughly 30,000–50,000 tokens per cycle. At Sonnet pricing, that's under $1 per publishing cycle. The quality review agent and the formatting step run on cheaper models — the total cost of producing three blog posts is approximately $1.50–$2.00 in API spend.
Time is where the real cost is. JP spends approximately 15 minutes per publishing cycle on review and approval — five minutes per post. Rip and Hormozi run autonomously; the agent time doesn't cost JP anything. The brief setup takes Rip about 10 minutes of agent time, drawing from the Trello export that's already generated for other purposes.
Total human time per three posts: 15 minutes. Total agent cost: under $2.00.
For comparison: a traditional content agency would charge $500–$1,500 for three posts of this quality. A freelance writer with genuine domain expertise would charge $300–$800 per post and would need to be briefed from scratch each time, since they don't have access to our operational history.
The leverage is real. The posts are better because they're grounded in actual work. They're cheaper because the production infrastructure is already built. They're consistent because the system runs on a schedule rather than depending on anyone's available attention.
What We're Not Doing
A few things that might seem obvious but we've explicitly decided against.
We're not publishing AI-generated content without review. Every post goes through JP. Not because we don't trust the quality of the drafts — the drafts are strong. Because the voice has to be right, and only JP can confirm that. One post that sounds wrong is harder to recover from than a two-day delay on publishing.
We're not optimizing for SEO at the expense of specificity. The posts are written for practitioners, not for search engines. If someone searches for "how to install Meta Pixel on a healthcare website" and finds our post, great. But we're not reverse-engineering keywords and writing to them. The value of the content is the operational detail. Dilute the detail to chase keywords and you lose the thing that makes it worth reading.
We're not building an editorial calendar in advance. The content comes from the work we're actually doing. If we pre-plan topics, we'll end up writing to a calendar instead of documenting what's real. The Trello board is the editorial calendar — whatever shipped this week is what we write about next week.
The Flywheel
The blog engine is part of a larger flywheel.
We build systems to run real operations — healthcare marketing, investment research, agent coordination, document management. We document what we build in detail. The documentation becomes blog posts that establish credibility with operators who are trying to solve the same problems. Some of those operators buy the ClawMart products — the playbooks and configuration files we've extracted from our own platform. The revenue from those products funds more platform development. Which creates more things to build and document.
The content isn't a separate strategy. It's a byproduct of building things that work, with enough operational discipline to write them down.
That's the design. This post is the proof of concept.
Frequently Asked Questions
How much does it cost to run an AI content pipeline?
Ours costs under $2 per publishing cycle — three posts at 1,500–2,000 words each. The writing agent runs on Claude Sonnet ($3–18/1M tokens); three posts consume roughly 30,000–50,000 tokens total. Review and formatting steps run on cheaper models. The larger cost is human time: approximately 15 minutes for JP to review and approve three drafts. Everything else runs without him.
Can AI write blog posts that don't sound like AI?
If the source material is operational — real decisions, real numbers, real problems that broke and got fixed — yes. The problem with most AI content isn't the model, it's the input. Generic prompts produce generic output. When the agent is working from a Trello board export, memory files, and specific operational detail, the result is grounded in something real. The voice guidelines matter too: no filler phrases, short paragraphs, specific details only. Follow those rules and the writing is indistinguishable from a practitioner who sat down and wrote it.
Why use Trello as the source for blog content?
Because it's the operational record. Every significant task — what was assigned, what got done, what broke, how long it took — flows through the board. At the end of each week, that board is a structured log of real work. Blog posts sourced from it are accurate by default. The alternative is reconstructing what happened from memory, which introduces gaps and forces generalization. The specific detail that makes practitioner-to-practitioner writing useful — "the regex match in GTM fixed the inconsistent redirect URL" — is in the Trello card, not in anyone's head.
Subscribe for Weekly Operational Updates
We publish one post per week documenting what we built, what broke, and what we learned. No motivation. No theory. Operational detail from a live platform.
Or if you're building something similar, the AI Operations Playbook — covering the full platform architecture, agent setup, and cost model — is available free at shopclawmart.com.
Get the AI Operations Playbook →
We document everything we build at plowman.ai. Products and playbooks available at shopclawmart.com.