Last Thursday I opened my laptop at 7am, and I saw that my scheduled AI newsletter workflow in Claude was completed while I was still in bed. It ran the /ai-newsletter research and write steps, and the draft was waiting for me. I edited it, cut two items, added one I’d spotted on my own, and typed /ai-newsletter publish all. The newsletter went to Notion, queued as a draft on Substack, generated a hero image, and created social posts for X, Facebook and LinkedIn. The whole thing, including my review time, took about 15 minutes.
Six months ago, that same workflow took me three to four hours. Every single week.
I want to be honest about what that sentence actually means, because “an AI system does it now” is doing a lot of work. I didn’t just hand over my newsletter to a chatbot. I designed a system, wrote documentation for it, defined how each part behaves, and made deliberate choices about where I stay in the editorial seat. The AI runs the system. I built the system. That distinction matters, and it’s the whole point of this series.
[The AI Newsletter Pipeline]
The Real Problem Wasn’t Writing. It Was Overhead.
The newsletter itself, “Latest in AI News,” is something I genuinely want to produce. I care about it. The content is valuable. But producing it involved a specific set of steps that had nothing to do with editorial judgment: scan sources, curate items, check for duplicates from last week, format everything consistently, write intro, write takeaways, export to Notion, draft on Substack, generate a cover image, create social posts for three platforms.
Every one of those steps is repetitive. Each one is mechanical. And every week, those steps consumed the time I actually wanted to spend reading, thinking, and deciding what was worth sharing.
This is the trap with most content workflows. The valuable work is judgment: deciding what matters, what to cut, what angle to take. The exhausting work is everything surrounding it. And most people, including me until recently, treat all of it as one undifferentiated block of effort called “producing the newsletter.”
Separating those two things was the design insight that changed everything.
What the System Actually Looks Like
The entire workflow runs on six components. This series covers each one in depth, so I’ll just give you the shape here.
The Directive is a Markdown file called write_ai_news_newsletter.md. Think of it as a permanent employee manual for my newsletter. It defines the newsletter structure, the date-range rules for news items, what sources to check, what sources to exclude, how to handle a slow news week, and about a dozen edge cases I’ve added over time every time something broke. It also points to my tone and voice guidelines: separate files built from examples of my actual writing, blog posts, reflections, and articles I’ve published over the years. The AI reads those before it writes a single word. That’s how the output sounds like me rather than a generic AI summary. The directive doesn’t change week to week. It’s the standing instruction set.
The Skill is a Claude Code command: /ai-newsletter. That single entry point routes the entire pipeline. It accepts sub-commands like /ai-newsletter research, /ai-newsletter write, and /ai-newsletter publish notion, so you can run individual stages or the whole thing. You can also just type in plain English: “write this week’s newsletter” works exactly as well as the slash command.
The four agents are specialists. The researcher scans 15-plus sources, checks what was published last week to avoid repeats, and produces a structured JSON file of 20-25 categorized news items. The writer formats those items into the newsletter structure and stops, leaving the introduction and key takeaways as placeholders. The publisher picks up after I’ve reviewed, generates the intro and takeaways from my final edited content, strips the review markers, fixes formatting for Notion and Substack, and publishes. The hero image agent extracts keywords from the final newsletter, filters out anything I cut, and composites a cover image.
Human review sits in the middle of that pipeline, not at the end. After the writer finishes, everything stops. I open the draft, read it, cut what isn’t worth my readers’ time, add anything I spotted that the AI missed, and mark it ready. The intro and takeaways are generated from that final, human-reviewed content. That’s the design choice that keeps the newsletter sounding like me.
Publishing goes three places: a Markdown file on disk, a new page in Notion, and a draft on Substack. Always a draft on Substack. I open it there and publish it manually. I customize it further to add nuances of the Substack platform. That’s another intentional choice, not an oversight.
Social posts come last. After publishing, /social-posts skill generates three variations each for X, LinkedIn, and Facebook, pulled from the actual published content. I pick what I like, tweak if needed, and post.
The Idea Behind All of It
If I had to put the core principle in one line:
“Prompts are the code. The directive is the SOP. The agents are your specialists. The human has the control.”
This is a 3-layer architecture. The directive defines what to do. Claude acts as the orchestrator, making routing decisions between agents. The agents and Python scripts do the actual execution. Each layer has one job. Each layer is separately improvable.
When something breaks, I don’t fix a prompt buried inside a Python class. I update the directive, and the fix is permanent. The system today is meaningfully smarter than it was in March, not because I rewrote anything from scratch, but because every failure became an update. Sub-bullet indentation broke in Notion. Fixed, documented, never broke again. Duplicate news items slipped through between weeks. Fixed, documented, never happened again. The system compounds.
I didn’t expect it to hold up as reliably as it has. But it has, week after week, for months.
What This Series Covers
This is the first post in a five-part series. Each part stands on its own, but they build on each other.
Part 1 covers the directive and the 3-layer architecture. If you’ve ever wondered why “just ask ChatGPT” falls apart for anything you need to repeat reliably, this explains the mismatch. LLMs are probabilistic. Business logic is deterministic. A directive is how you bridge that gap.
Part 2 goes deep on the skill: how one command routes an entire pipeline, the Draft-First Check that prevents wasted work, and the marker system that lets you control the draft with editorial annotations like [DO NOT PUBLISH] and [NEW ITEM]. You’ll see how natural language commands map to agent routing without any code changes.
Part 3 walks through all four agents, what each one owns, what it’s explicitly not allowed to do, and why the human review step lives in the middle of the pipeline instead of the end. Boundaries between agents are a design choice. Scope creep between agents is how quality quietly degrades.
Part 4 shows you the actual outputs, the actual failures, and the self-annealing principle that makes the system better over time. Then I’ll show you how the same three-layer pattern works for any repeating workflow you’re running: executive briefings, competitive intelligence, content calendars, sales research pipelines. The newsletter is just one example of a class of problem.
If you want to see the newsletter this system produces, you can subscribe at rupakganguly.substack.com. Every edition was researched, drafted, and published through the workflow I just described. What you get is a curated weekly digest of what actually matters in AI, without the noise.
And if you’re building something like this yourself, or just curious how far you can push an agentic workflow before it breaks, follow along. I’m sharing everything: the architecture, the failures, the fixes, and the exact files. The next post is already the one I wish I’d had when I started.
Drop me a message if you’re already running something similar, or if you’ve tried and hit a wall. I’d genuinely love to hear what broke.