- Automate the busywork around the editor, not the editor.
- Build separate stages, each with a clear input, output and owner, so any one can be checked, paused or swapped.
- Put people at three gates: the story list, the draft and the final render.
- Draft only from source text the pipeline saved, and check every link against the sentence it supports.
- Match the model to the task: small and cheap for sorting and checks, your strongest for drafting.
- Give every stage a fallback that still lets the editor ship by hand.
- Roll out one stage at a time, starting with research and ranking.
Start with the job, not the model
A newsletter issue is not one task. It is a dozen small ones: finding stories, ranking them, checking sources, writing, formatting, filling sponsor slots, scheduling and sending. Language models are very good at some of these and unreliable at others. The trick is to give each step to the right worker, person or machine, and to connect them so nothing gets copied and pasted.
When we build a production pipeline, we map those steps first. Only then do we decide where AI earns its place.
Write the map down. For each step, note four things:
- Input. What it starts from: a feed, a list of links, a draft.
- Output. What it hands on, in a fixed format.
- Owner. Who fixes it when it breaks.
- Time today. Minutes per issue, measured over a few real issues, not guessed.
The time column sets your order of work. The output column tells you whether a step can be automated at all. If you cannot describe what good output looks like, a model cannot produce it reliably either.
The pipeline, stage by stage
- Research: 42 stories pulled from 11 sourcesDone
- Ranked and deduplicated against last 10 issuesDone
- Draft: 6 sections, 1,240 words, house styleDone
- Checks: citations, grounding, topic and tone18/18
- Render: template v4 with sponsor Northwind FreightDone
- Scheduled in ESP for 6:30 AM, pending approvalReview
Illustrative example. Names and figures are fictional.
1. Sources
Pull candidate stories automatically from the feeds, sites and data sources your editor already trusts. Public data APIs are worth adding here: numbers that refresh themselves before every issue are one less thing to look up.
How to check it: every source has a tier and a reason to be on the list. If nobody can say why a feed is there, take it off.
2. Research and ranking
Rank stories by relevance and source quality, and remove anything covered in recent issues. A simple source-tier list, with primary reporting above aggregators, does more for quality than any prompt.
Save the full text of each candidate story, not just the link. Every later stage works from that saved text, and that is what makes checking possible.
How to check it: compare the pipeline's top ten with your editor's picks for a few weeks. Where they disagree, ask why, and write the answer into the ranking rules.
3. Drafting
Draft in your house style, from your best past issues, with explicit rules: length per section, tone, words you never use. Give the model the saved source text for each story and tell it to use nothing else. Treat the draft as a first pass for your editor, never as finished copy.
How to check it: compare each draft with the issue that was actually published. The edits your editor makes again and again are your next style rules.
4. Checks
This is where most pipelines cut corners, and where yours should not. Check that every citation points to a source that actually supports the sentence, that claims are grounded in the source text, and that nothing off-topic slipped in. A second, cheaper model is well suited to this kind of verification.
Run the checks as separate pass or fail tests. One prompt asking whether the issue is good tells you nothing you can act on.
How to check it: every so often, plant a wrong link in a test draft. If the checks pass it, they are not working.
5. Rendering
Fill a tested email template automatically, including any sponsor slot booked for that date, with the right disclosure label and tracked links.
How to check it: send a test to Gmail, Outlook and a phone before approval. Look at the sponsor slot and its label, confirm every tracked link resolves, and screen the subject line for spam-trigger wording. Our deliverability checklist covers the rest.
6. Review and send
The draft lands in your ESP as a scheduled draft, not a sent email. Your editor reads it, changes what they want and approves the send.
Check what your platform's API allows before you design this step. On Beehiiv, creating posts through the API is limited to higher-tier plans (Pro and Enterprise at the time of review). Resend's broadcast API creates a broadcast without sending it unless you ask, and only accepts a send time when you do send. Both point to the same rule: create the draft automatically, and attach the send time only after the editor approves.
Where people stay in charge
One review at the end is not enough. By then the editor is checking a finished issue against the clock, and a weak story is expensive to swap. Put people at three gates.
- The story list. The editor approves, cuts or adds stories before drafting starts. Five minutes here saves thirty later.
- The draft. The editor reads every word, with the check results beside it. Failed checks sit at the top, not buried in a log.
- The final render. One look at the real email, sponsor slot and links in place, then approve.
Keep the gates fast. A slow gate gets skipped on a busy morning, and a skipped gate is worse than none, because everyone assumes it happened.
Choosing a model for each task
No single model is right for every stage. Match the model to how hard the task is and what a mistake costs.
| Task | What it needs | Model choice | Human gate |
|---|---|---|---|
| Tagging and deduplicating stories | Speed, consistency, structured output | Small, fast model | Spot checks |
| Ranking stories | Judgment against written rules | Mid-tier model | Editor approves the list |
| Drafting sections | Voice, compression, following a style guide | Your strongest writing model | Editor reads every word |
| Citation and grounding checks | Careful reading against source text, one claim at a time | Small or mid-tier model | Failures go to the editor |
| Subject line options | Variety within rules | Mid-tier model | Editor picks one |
Test before you choose. Take ten past issues, run each candidate model on the same inputs, and have the editor grade the drafts without knowing which model wrote which. Keep that test set. When a provider releases a new model, rerun it before you switch.
Pin the exact model version in production. A silent upgrade can change tone or length overnight, and you want that change on a day you chose.
Write a style guide a model can follow
A style guide for writers is full of taste. A model needs rules: short, specific and testable.
- Structure. The sections, their order and a word range for each.
- Voice. A few sentences of description, plus two or three of your best past paragraphs as examples.
- Banned words and patterns. The phrases your editor always cuts, and names you never mention. A short list of hard rules beats a long, polite prompt.
- Facts. Use only the supplied source text. If the sources do not say it, leave it out.
- Uncertainty. When sources are thin or disagree, flag it in a note to the editor instead of smoothing it over.
- Names and numbers. Copy them exactly from the source, with units.
Version the guide like code. Every rule change gets a date, so you can see whether the next drafts improved.
Hallucination controls
Models make things up. The goal is not to trust them more. It is to make every claim easy to check and hard to slip through.
- Ground in saved text. Draft only from the source text the pipeline stored, and tell the model not to use its general knowledge.
- Quotes first. For long sources, have the model pull the exact quotes it will rely on before it writes. The checks then have something concrete to compare.
- Allow "not enough information". Explicit permission to admit uncertainty cuts invented detail. Route those notes to the editor.
- Verify after drafting. For every factual sentence, find a supporting quote in the source. No quote, no claim.
- Use structured output. Ask for drafts and check results as JSON that matches a schema. Anthropic and OpenAI both offer structured output modes built for this, so a malformed answer does not break the next stage. Still handle the rare refusal or cut-off response.
Providers' own guidance is clear that these techniques reduce errors without removing them. That is why the editor gate stays.
Illustrative example. Figures are fictional.
In this fictional run, the draft says a strike closed one port and links to a story about another. The sentence may even be true. The link does not prove it, so the draft reaches the editor with that check at the top.
Keep costs predictable
- Spend where it shows. Use your strongest model for drafting and smaller ones for sorting and checks.
- Batch what can wait. Anthropic's Message Batches API and OpenAI's Batch API both cost half the standard rate, in exchange for results that can take up to 24 hours. Use them for overnight jobs like tagging the archive, never for the 6 a.m. run.
- Cache what repeats. Your style guide and examples are the same on every call. Anthropic's prompt caching bills reused prompt prefixes at a fraction of the normal input price. Its default cache lasts five minutes, so it pays off when the calls for one issue run close together.
- Set a ceiling. Cap usage per run and alert when a run goes over. A retry loop with no limit is the usual cause of a surprise bill.
When a stage fails
It is 6:04 a.m. on send day and the drafting call has timed out twice. What happens next should be decided now, not then.
- Retry with limits. A couple of retries with a pause between them, then stop.
- Keep kill switches. Pause any one stage without breaking the rest.
- Fail loudly. Message a person with the stage and the error. A log line nobody reads is not an alert.
- Degrade, do not block. If drafting fails, hand the editor the approved story list and research briefs. They can still write the issue by hand.
- Never send around a failure. A failed check blocks approval until someone reads it. It is never skipped to make the deadline.
- Make reruns safe. Running a stage twice should not create two drafts or two scheduled sends.
Rehearse the manual path once a quarter. If the editor has not built an issue without the pipeline in months, the fallback only exists on paper.
What never to automate
- The decision to publish. A person approves every send.
- Corrections. A person writes them, approves them and decides where they run.
- Sponsor copy. Sponsors approve their ad. A model never rewrites it.
- Replies to readers. Readers write to a person and should hear back from one.
- Sensitive stories. Allegations, legal disputes, deaths and anything else that names a person in a damaging light.
The pattern is simple. If a mistake would hurt a real person, break a contract or be impossible to take back, a person does it.
Disclosure and the EU AI Act
If you publish to readers in the EU, look at the AI Act. Article 50 has applied since 2 August 2026. It requires deployers to label AI-generated text published to inform the public on matters of public interest.
There is an exception that matters for newsletters. The Act exempts text that has undergone human review or editorial control, with a person or company holding editorial responsibility. The European Commission's guidance adds that spell-checking or grammar fixes alone do not count.
A real editor gate, one that can reject a draft, is good practice either way. Whether you also tell readers how the issue is made is an editorial choice. This is not legal advice, so check your own situation with counsel.
Roll it out in phases
Do not automate everything at once. Run each phase alongside the old process before it replaces anything.
- Research and ranking. The pipeline proposes a story list. The editor still writes everything. Move on when the editor uses most of the list as proposed.
- Research briefs. Each approved story gets a short brief with quotes and links. Move on when spot checks of the briefs stop turning up errors.
- Drafting with checks. Drafts arrive with their check results. Run them in parallel for a few issues and compare editing time with writing from scratch.
- Rendering and scheduling. Approved copy fills the template and lands in the ESP. This comes last because it touches the send.
Some newsletters stop after phase two. That is a fine outcome.
What most guides miss
Lessons from systems we have built and run, not the usual checklist.
Repetition is the quiet killer
Most pipelines check a single issue in isolation. Readers notice when the same story, source or angle shows up three issues in a row. Check every draft against your recent issues, not just against itself.
Check the citation, not just the claim
A model can write a true sentence and attach the wrong link. Verify that each linked source actually supports the sentence it sits next to. A second, cheaper model does this well.
A citations feature is not a fact check
Anthropic's Citations feature guarantees that each citation points to a real passage in the documents you supplied. It does not promise that the passage supports the sentence. You still need the claim-by-claim check.
Review fatigue is a real failure mode
When the pipeline is right nineteen times, the editor skims the twentieth. Keep the list of flagged items short, so it gets read every time. A gate that cries wolf trains people to ignore it.
Warm the archive before you send
If issues link to a web archive, load those pages before the email goes out. The first readers to click should not be the ones waiting for a slow page.
How we do it
We built this kind of pipeline for an independent B2B trade newsletter published three times a week by one operator. It has produced every issue since launch, and the editor still reads and approves each one. Read the case study, or see what we build for operations.
Not sure which steps to automate first? A process audit maps how your issue gets made today and shows what to build first.
Sources
- Beehiiv Developer Documentation: Create post
- Resend Docs: Create broadcast
- Resend Docs: Send broadcast
- Anthropic Docs: Reduce hallucinations
- Anthropic Docs: Structured outputs
- OpenAI API Docs: Structured outputs
- Anthropic Docs: Batch processing
- OpenAI API Docs: Batch API
- Anthropic Docs: Prompt caching
- Anthropic Docs: Citations
- European Commission AI Act Service Desk: Article 50, Transparency obligations
- European Commission: Code of Practice on transparency of AI-generated content
Facts checked against these sources in October 2026.