Let me tell you the problem first: I have a full-time role leading AI products at HCLTech, a personal brand I'm building from scratch, a D2C handloom brand called Ethlore, and approximately 4 hours per evening to work on all of it. Publishing consistent, quality content without automation is not a strategy - it's a fantasy.
So I built Jarvis. Not the Marvel one, unfortunately. A personal AI operating system that handles the parts of my content pipeline that don't require my specific judgment. Here's what it looks like from the inside.
The 3-Layer Architecture
The system I built follows a strict separation of concerns across three layers:
Layer 1: Directives (What to do)
These are Markdown files in a directives/ folder. Each one is essentially an SOP - it defines goals, inputs, tools, expected outputs, and edge cases. Think of them as the instructions you'd give a knowledgeable employee: thorough enough that they can execute without constant check-ins, but not so prescriptive that they can't adapt.
I have directives for everything: how to research and draft a blog post, how to batch-publish to Ghost, how to generate the weekly newsletter, how to run analytics and surface the top-performing posts. About 40 directives in total, covering every repeatable workflow in my content operation.
Layer 2: Orchestration (Decision-making)
This is the AI layer - Claude, specifically. Its job is intelligent routing: read the directive, determine the right sequence of execution steps, handle errors, and ask for clarification on ambiguous inputs. It doesn't do the actual work. It decides what work to do and in what order.
The orchestrator also self-improves. When it hits an error - an API rate limit, a malformed response, a scraping block - it fixes the execution script, tests the fix, and updates the directive with what it learned. The system gets smarter with every failure. I call this self-annealing.
Layer 3: Execution (The actual work)
Deterministic Python scripts in an execution/ folder. These handle API calls, data processing, file operations, content formatting. They're fast, testable, and reliable. When the orchestrator says "publish batch 3," the execution script handles every API call, JWT token refresh, rate limiting, and error retry without further AI involvement.
Why this architecture? Because AI is probabilistic. 90% accuracy per step compounds badly: five steps at 90% each gives you 59% end-to-end success. The solution is to push complexity into deterministic code and let the AI focus on the decisions that actually require judgment.
The Content Research Pipeline
When I want to publish a new post, the flow starts with a topic directive. I describe what I want to write about - the angle, the target audience, the approximate length, any specific examples I want included. The orchestrator takes that and calls a research script that pulls from multiple sources: recent AI papers, industry news, my own prior posts (to avoid redundancy and to find linking opportunities), and keyword data.
The research output is a structured JSON object: topic, key points, supporting evidence, potential objections, related posts for internal linking. It takes about 90 seconds to generate what would have taken me 2-3 hours of manual research.
The draft is then generated from the research output - not from scratch. This distinction matters. Drafting from a structured research object produces more coherent, better-cited content than prompting a blank generation. The output still requires my editing pass, but it's editing, not writing. That's a 10x productivity difference for me personally.
Batch Publishing to Ghost
Ghost has an excellent Admin API. My execution layer uses it to publish posts in configurable batches, handling:
- JWT token generation and refresh (Ghost tokens expire every 5 minutes)
- Rate limiting (1.5 second delays between posts)
- Tag management (creating tags that don't exist yet)
- Meta title, meta description, and excerpt population
- Status management (draft vs. published)
- Error logging with retry logic
A typical batch run publishes 10-20 posts in under 2 minutes with zero manual intervention. The posts come out formatted correctly, tagged appropriately, and SEO-ready. I review a random sample after each batch to check quality, but I've never had to roll back a batch.
The Newsletter Generator
Every week the system automatically:
- Pulls the last 7 days of posts from Ghost's Content API
- Ranks them by expected value (based on topic freshness, depth, and my personal weighting)
- Drafts a newsletter with a brief intro, 3-5 featured posts with summaries, and a closing thought
- Formats it for Ghost's email feature
- Saves it as a draft for my final review before sending
I still do the final edit and send manually. That's intentional. The newsletter is the highest-trust touchpoint with my audience. I want a human hand on it, even if the 80% draft is automated.
Content Analytics Automation
I run a weekly analytics pull that compares content performance across three dimensions: search traffic (via Search Console API), engagement (time on page, scroll depth), and social sharing. The output is a Google Sheet that I review every Sunday.
The system also generates a recommendation: which topic clusters are gaining momentum, which posts need internal link reinforcement, which comparison posts could be updated to stay evergreen. It's not magic - it's pattern matching against data I'd be reading anyway, surfaced in a more actionable format.
The Audio Pipeline
Every published post automatically gets queued for an audio version. I'm using ElevenLabs for voice synthesis - my cloned voice, trained on 30 minutes of clean audio. The pipeline converts the HTML post to clean text (stripping code blocks, formatting for audio), submits to ElevenLabs, and saves the output to a CDN folder.
The audio player widget on each post loads from that CDN path. It's not perfect - ElevenLabs occasionally mispronounces technical terms - but the production quality is good enough that multiple readers have mentioned the audio option as a feature they actually use.
The Honest Trade-offs
Automation removes friction and introduces distance. When I write every word manually, I'm deeply connected to every piece. When 80% of the scaffolding is generated, I have to work harder to maintain that connection - to make sure my actual perspective shows up in the editing pass rather than defaulting to whatever the AI drafted.
I've also had to develop a discipline around reviewing automated output. The temptation when a batch runs cleanly is to skip the spot-check. I've learned to resist that. The quality drift that comes from unreviewed automation is slow and hard to detect until it's a problem.
The system works because I built it around my actual workflow constraints: limited time, need for consistency, high quality bar, strong opinions about voice and framing. If your constraints are different, the architecture would look different too. This isn't a template - it's a design pattern applied to a specific context.
What's Next
I'm currently building the analytics feedback loop - where content performance data automatically informs the next batch of topic suggestions. If comparison posts are outperforming think-pieces, the system should learn that and weight future research accordingly.
I'm also adding A/B testing for headlines. Ghost supports draft versions, and I can use the API to test two titles on the same content and track which one gets more organic clicks. This is table stakes for a real content operation.
The thing I keep coming back to: building this system has taught me more about content strategy than reading about content strategy ever did. When you automate something, you're forced to make the implicit explicit. You have to define what "good" looks like in terms a machine can evaluate. That discipline improves your own thinking, not just your output.
The pipeline is open - if you want to see specific parts of the code, or want to understand how any particular piece works, just ask.
