You wrote a 600-word issue on Sunday. It's fine. A bit baggy in the middle, an opening that clears its throat. You paste it into a chatbot with "make this better" and get back something smooth, confident and unrecognisable. Worse, it now includes a statistic you never wrote.
AI prompts for newsletter writers work best when the order is flipped: you write, the model critiques, you decide. This post gives you an editing-first workflow with copy-paste prompts, a subject-line process, and a script that audits what a model changed so you can see voice drift in numbers. The script and its output are real (run 2026-10-09). The draft and the "AI edit" in the example are mine and illustrative; the prompts are untested templates.
If you want AI to start from your video transcripts instead, see the newsletter from YouTube transcripts workflow. This post is for writers who draft themselves.
Why edit first and generate later?
Generation fills a blank page with the most average version of a newsletter. Editing starts from your take. The other reason is risk: the more of the text a model wrote, the more of it you must fact-check, and fixing a model's tone costs more than fixing your own clumsy sentence.
A practical rule: the model may suggest, point, ask, list and compare. It may not silently replace. Anything it proposes should arrive as a suggestion you accept or reject.
What is the editing-first workflow?
- Write a rough draft in your own words, including the opinion. Ugly is fine.
- Ask for a diagnosis, not a rewrite (prompt 1).
- Fix the issues yourself, or ask for options on one paragraph at a time (prompt 2).
- Run a voice check on anything the model rewrote (the audit script below).
- Subject lines last, from the finished text (prompt 3).
- Read it aloud once. Anything that you wouldn't say gets cut.
Prompt 1: the critique that doesn't rewrite
Untested template:
You are a blunt editor for a newsletter called {{NAME}} that goes to
{{AUDIENCE}}. Its voice: {{3 ADJECTIVES AND ONE SENTENCE ON HOW YOU WRITE}}.
Below is my draft. Do NOT rewrite any of it. Do NOT add facts, numbers,
quotes or examples. Return:
1. The single main point of the issue, in one sentence. If you cannot
find one, say so.
2. The 3 weakest passages, each quoted exactly, with one sentence on why.
3. Anywhere I make a claim without support (list the sentence).
4. Where a reader would likely stop reading, and why.
5. What I'd cut, in order of how little it would be missed.
DRAFT:
{{PASTE}}
Item 3 matters most for trust: it makes the model point to your unsupported claims instead of adding its own. Item 1 is a quick test of whether the issue has a point. If the model's one-sentence summary is not what you meant, your readers will miss it too.
Prompt 2: paragraph-level options
When one paragraph is the problem, ask for variants of that paragraph only:
Here is one paragraph from my newsletter and the paragraph before it.
Give me 3 alternative versions of the paragraph that keep my meaning and
my word choices where possible, and shorten it by about a third.
Rules: no new facts, no new numbers, no new names, keep my first-person
voice, no sentence longer than 25 words. Label each version A, B, C and
list in one line what you changed.
PREVIOUS: {{PASTE}}
PARAGRAPH: {{PASTE}}
Pick one, then edit it with your own hands. The "list what you changed" line makes it easy to see when a version quietly altered the meaning.
For deeper style work (building a style document, giving samples), prompting for writers covers it, and how to prompt AI to sound human catalogues the patterns that give machine text away. This post doesn't repeat either.
How do you know if the AI edit changed too much?
Eyeballing doesn't work, because smooth text reads as good. So measure. The script below compares your draft with the edited version and reports:
- the share of your words that survive
- how many sentences are untouched
- average sentence length before and after
- numbers and capitalised words that are new
- a short list of stock phrases that weren't in your draft
- the em dash count
Save as edit_audit.py and run python3 edit_audit.py draft.txt edited.txt. Standard library only.
import re, sys
from difflib import SequenceMatcher
orig = open(sys.argv[1]).read()
edit = open(sys.argv[2]).read()
TELLS = ["delve", "it's worth noting", "in today's", "game-changer", "unlock",
"leverage", "seamless", "in conclusion", "dive into", "landscape"]
def words(s):
return re.findall(r"[A-Za-z0-9'’]+", s.lower())
def sents(s):
return [" ".join(x.split()) for x in re.split(r"(?<=[.!?])\s+", s.strip()) if x.strip()]
ow, ew = words(orig), words(edit)
kept = sum(b.size for b in SequenceMatcher(None, ow, ew, autojunk=False).get_matching_blocks())
print(f"words kept from original: {kept / len(ow):.0%} ({kept}/{len(ow)})")
os_, es = sents(orig), sents(edit)
same = sum(1 for s in es if s in os_)
print(f"sentences unchanged: {same}/{len(es)} in edit, {len(os_)} in original")
def avg(ss):
return sum(len(words(x)) for x in ss) / max(1, len(ss))
print(f"avg sentence length: {avg(os_):.1f} -> {avg(es):.1f} words")
new_nums = sorted(set(re.findall(r"\d+(?:\.\d+)?", edit)) - set(re.findall(r"\d+(?:\.\d+)?", orig)))
print("new numbers:", new_nums or "none")
cap = lambda s: set(re.findall(r"(?<![.!?]\s)(?<!^)\b([A-Z][a-z]{2,})\b", s))
print("new capitalised words:", sorted(cap(edit) - cap(orig)) or "none")
hits = [t for t in TELLS if t in edit.lower() and t not in orig.lower()]
print("new AI-tell phrases:", hits or "none")
print(f"em dashes: {orig.count(chr(8212))} -> {edit.count(chr(8212))}")
My test draft, written by me, is a six-sentence paragraph about checking email twice a day:
I used to hate Mondays. Not the work, the inbox. Last week I tried a boring
fix: I only open email twice a day. It felt rude at first. Then Tuesday went
by and nothing burned down. My reply time slipped a bit, and I can live
with that.
The "AI edit" I hand-wrote to imitate what a "make it better" prompt tends to produce (illustrative, not captured from a model):
In today's fast-paced world, many professionals dread Mondays, and the inbox
is often the culprit. Last week I decided to leverage a simple strategy:
checking email just twice a day. It felt rude at first. Then Tuesday went by
and nothing burned down. According to Gartner, 40 percent of workers see
productivity gains from this approach, and my reply time slipped only
slightly.
Real output of the script:
words kept from original: 57% (28/49)
sentences unchanged: 2/5 in edit, 6 in original
avg sentence length: 8.2 -> 12.8 words
new numbers: ['40']
new capitalised words: ['Gartner']
new AI-tell phrases: ["in today's", 'leverage']
em dashes: 0 -> 0
Read that as a diagnosis. Four of your six original sentences changed or vanished and the rhythm flattened (8.2 to 12.8 words per sentence means the short punchy lines got merged). A fabricated source and statistic appeared. Two stock phrases arrived. The script cannot tell you whether the edit is better; it tells you where to look.
Limits: it counts words, not meaning. A model can reverse your point using only your own words, and the script will report a high retention rate. The capitalised-word check is crude and misses names at sentence starts. The phrase list is mine and short; add the phrases that annoy you.
A useful threshold is your own. Run the script on a few edits you were happy with and a few you rejected, and see what the numbers look like for you. I did not find a standard benchmark, so I'm not giving one.
Prompt 3: subject lines from the finished issue
Do this last, from the final text, so the subject line doesn't promise something the issue doesn't deliver.
Here is the final text of my newsletter issue:
{{PASTE}}
Write 10 subject lines and a preview text for each. Rules:
- Each subject line must be true to this issue; no claim, number or name
that is not in the text.
- 3 plain and specific, 3 curiosity-led but still honest, 2 that start
with a question, 2 in my usual style: {{PASTE 3 PAST SUBJECT LINES}}.
- No "you won't believe", no all caps, no emoji.
- Flag any line the issue does not fully pay off.
Cut the ones that overpromise. Test two against each other with your own list if your email tool supports it, and compare against your own history. Preview truncation differs between email apps and phones, so check how your own subject lines appear in a few real inboxes rather than trusting a character count from an article.
What should you never automate?
- The opinion. If the issue exists because you think something, that part is you.
- Quotes and attributions. Any quote of a real person should come from a source you read.
- Numbers and claims about other people or companies. Verify against the original page; the fact-checking checklist shows how.
- Sponsor copy and disclosure. Write or at least approve every word.
- Replies to subscribers. A personal reply is part of why they stay.
- Sending. Read the final version once in the actual email preview.
For repurposing finished issues into other formats rather than editing them, see AI content repurposing prompts. If you also publish video, the YouTube creators prompt guide covers scripts and descriptions.
A weekly routine that takes about 45 minutes
This is a suggested shape, not a measured one. Adjust to your list.
- Draft (20 min, no AI).
- Critique prompt, then fix the three weakest passages yourself (10 min).
- Optional paragraph options on the one that still bothers you (5 min).
- Audit script if any paragraph was rewritten (2 min).
- Subject lines and preview text (5 min).
- Read aloud and send a test to yourself (3 min).
What I'd skip
Skip the "rewrite this in my voice" prompt as a standing habit. It sounds efficient and it produces text that is almost you, which is the uncanny kind. Skip asking for "more engaging" after your final check, since each rewrite is a new chance to add an unchecked claim. And skip the idea that a model can judge what your readers want: ask your readers, by hitting reply.
