I Built a PHP Agent That Drafts My Blog Posts for Eight Cents

I'm a husband, a dad, a grandfather, I work a regular 9-to-5, and I own a house that constantly reminds me it needs attention. Blogging at a professional cadence — the kind that actually serves mid-to-senior Drupal developers — means either burning out or finding a fundamentally different workflow.

Most AI content tools offer you a false binary. Door number one: write everything yourself, manually, staring at that cursor until something good happens. Door number two: feed a prompt into a free AI writer or something like Jasper and get back 1,200 words of "In the ever-evolving landscape of content management..." that your audience would identify as AI slop before finishing the first paragraph.

Neither option works for technical depth. Neither respects the reader *or* the author.

So I built a third option. A scrappy PHP/Symfony CLI tool with a voice profile, a cache directory, and a hard approval gate between outline and draft. I built it for myself, because the blank cursor kept winning.

Then DrupalCon Chicago happened.

Dries took the stage for the Driesnote and walked through the Context Control Center — a centralized repository for organizational knowledge that gives AI specific brand guidelines, writing tone, content strategies, and a structured context layer so outputs don't drift into generic noise. The architecture was deliberate, governed, and human-in-the-loop.

I'd marked my writing profiles feature complete two months earlier.

Same architectural DNA. One built for enterprises scaling to thousands of pages. One built for a developer who just wanted to publish without burning out. If you want to see where the parallel lands, watch Dries describe it during his DrupalCon Chicago 2026 Keynote — then come back and look at this table.

Dries solved the context problem for organizations. I solved it for the person staring at a blank cursor. The approach is the same. The packaging is not.

Here's how it works.

First Mate, Not the Captain

Let me be precise about the relationship here. The agent I built is a Compiler. A Scaffolding Tool. An Apprentice. I am the Lead Architect. The technical expertise, the opinions, the "I've been in the trenches and here's what actually works" perspective — that's mine. The agent removes the friction between an idea in my head and a published post on the screen. That's it.

This isn't AI copywriting that replaces the author. It's high-fidelity assistance that lets me shift from a "writing" mindset" to an "Architectural Direction" mindset I spend more time on storytelling, on selecting the right angle, on varied pacing — and less time fighting the blank cursor.

Think of it like this: an architect doesn't lay every brick. But every brick gets laid according to the architect's blueprints, under the architect's supervision. The moment you remove that supervision, you get a strip mall where a cathedral was supposed to be.

AI content generators that optimize for volume over voice? Strip malls.

The Two-Pass Pipeline: Blueprints, Then Build

The agent runs on a two-pass pipeline, and the metaphor maps to exactly what it sounds like.

Pass 1 — "Blueprints." I feed the agent a topic, reference materials, and editorial notes. It generates an outline and context notes, storing the artifacts in the cache/ directory. That directory functions as a local equivalent of a RAG retrieval layer — structured context that gets pulled in at generation time to keep the agent grounded in my source material, not its training data's generic knowledge.

Then I review. Edit. Approve or reject it. This is a hard gate, not a suggestion box. No draft gets produced without explicit sign-off on the outline. Architectural integrity requires reviewing the foundation before the build.

Pass 2 — "Build." The approved outline feeds back in alongside branding.md — the voice profile. That markdown file is the agent's brain. It contains tone rules, banned phrases (goodbye, "delve into"), audience definitions, structural constraints, phrase patterns I actually use, CTA patterns, even rules about code examples. Every word the agent produces gets filtered through that profile.

The result: a rough draft that sounds like me, not like a language model doing its best impression of a tech blogger.

Here's where it gets interesting. The agent supports multiple profiles. One agent, multiple blogs, completely distinct voices. Each profile gets its own branding.md. Same pipeline, different architectural constraints. Different personality out the other end.

One discovery I didn't plan for — call it an Easter egg from testing: rather than cramming complex editorial direction into a notes column in my content spreadsheet, I can drop detailed instructions into a standalone markdown file and reference it in the spreadsheet's "References" column. The agent picks it up as context. More room to think, better results.

If that two-pass approval gate sounds familiar, it should. It's the same pattern as a CI/CD review gate. Code gets written, goes through review, gets approved or sent back — then it ships. Nobody pushes straight to production. The pipeline enforces that discipline for content.

Why PHP, and Why Outside Drupal

"Why not Python?"

Because PHP is the language of the Odyssey. My audience writes PHP daily. Symfony components have been native since Drupal 8. The patterns in this agent — service containers, config-as-code, structured pipelines — mirror what Drupal developers already understand. The choice reinforces credibility and transferability. If you wanted to fork this approach, you wouldn't need to context-switch into a different ecosystem.

But the deeper motivation: I wanted to understand how AI-assisted workflows actually function at a fundamental level before reaching for AI features inside Drupal's ecosystem. Learn by building outside the comfort zone first.

And that learning paid off. If you want the full architectural breakdown of how my CLI patterns map to what Drupal is formalizing in the CCC, I wrote that up separately. The short version is in the table above.

Eight Cents and a Proof of Concept

The end-to-end cost per blog post — outline generation through full draft — runs between $0.04 and $0.08. At the high end, publishing weekly for a full year costs $4.16 annually.

My time is worth well more than that.

But cost isn't the proof. This post is.

The agent read its own source code  as reference material to generate this draft. It consumed its own implementation files, its own branding.md, its own cache/ artifacts — and produced the post you're reading about how it works. That's not a disclaimer I'm burying in the footer. That's the demonstration. The meta-proof that the pipeline holds up when pointed at itself.

Did I edit the output? Did I make changes? Absolutely. The Lead Architect always reviews the build. But the heavy lifting — the structural assembly, the first-pass prose, the section pacing — came from directing the agent rather than fighting a blank cursor. This isn't a polished product yet. But it's a working system solving a real problem in my workflow. And I keep wondering how many other developers are staring at that same blank cursor.

The Shift

The real change isn't technological. It's a mindset shift from writer to editorial director of my own content. I still own every opinion, every architectural judgment, every "wait, why are we doing this again?" moment. But I'm spending my limited bandwidth on the parts that require a human with over a decade of Drupal experience — not on the mechanical labor of assembling paragraphs.

The Odyssey has always been about growth through solving hard problems. This one just happened to be about my own publishing workflow. Whether the "Human-in-the-Loop" approach is the future of technical blogging or just another tool that'll get replaced in six months — I genuinely don't know. But right now, it works. And at eight cents a post, the experiment is cheap enough to keep running.

Is the "Human-in-the-Loop" approach the future of technical blogging, or is it just more technical debt for developers? I want to hear your take.