Open your Brevo template list and you are doing archaeology. 80 lifecycle emails, written by three people across three versions of the brand voice: the founder's chatty layer from 2021, the agency's formal layer from 2023, and the current voice that only the newest templates speak. Under all of it sits the welcome sequence nobody has dared touch in two years, because one wrong character inside {{ contact.FIRSTNAME }} greets every new signup with broken code instead of their name. Brevo offers one way to fix any of this: open a template, edit, save, repeat. There is no search across templates, no find-and-replace, and the subject line lives in a different pane from the body. The voice pass everyone agrees the library needs has no tool to run in.
AI can write that pass; the rewriting was never the hard part. The hard part is proving, across all 80 templates at once, that the merge tags, the links, and the unsubscribe blocks came through untouched, and reading every subject line before it lands in an inbox. The job has a workable shape: pull every template into local files, let your own AI agent run the rewrite under your rules, review each change as a word-level diff with the braces visibly intact, and publish only what you approve. The routes below differ less in writing quality than in proof. Look for the one that shows you every brace intact while the send can still be stopped.
Your options
One template at a time, in Brevo
For a single template, Brevo's editor takes good care of you: undo, version history with restore, and Aura, Brevo's built-in AI, drafts subject lines and body copy in the editor, with subject suggestions informed by past performance. The walls are all horizontal. There is no search across template content and no find-and-replace, so "which templates still say the old product name" means opening all 80. Subject sits in the settings pane and body in the design pane, two stops per template. Saved sections sync shared headers and footers, syncing them into existing templates is gated to the top plans, and sections cover blocks, not voice. At a careful 15 minutes per template, the pass is 20 hours of clicking.
Duplicate and rebuild
Brevo's own recommendation before a risky edit: three-dot menu, Duplicate, and the copy lands in the Inactive tab as your working draft while the original keeps serving. For one nervous edit, say the welcome email, this is sensible. For a library pass it doubles the excavation. 80 templates become 160, the rewritten copies sit inactive until each one is activated, and every transactional call or automation that references the original template ID keeps using the old copy until you repoint it by hand. Six months later nobody remembers whether "Welcome v2 FINAL" or "Welcome (copy)" is the live one. The safety is real. It is also how the archaeology formed.
A chatbot per template
Paste a template's subject and HTML into a chat and the rewrite comes back genuinely good. This is the right writing with the wrong plumbing. 80 templates means 80 round trips, and the chat rewriting template 61 has never seen the other 79, so the voice drifts batch to batch. The merge tags ride along as plain text, and a model that tidies the braces or trims the unsubscribe block has done damage you can only catch by eyeballing pasted HTML. There is no diff. At 10 careful minutes per round trip the pass costs 13 hours, and the verification is the part that gets skipped when you are tired.
Scripts on the Brevo API
The honest fast route, if unsupervised is acceptable. One GET on /v3/smtp/templates pages through the whole library, up to 1,000 templates per call, and a PUT per template updates only the fields you send. Wire an AI agent to it and you get judgment with reach. You also get no preview: each PUT lands on the live template the moment it runs, and the next transactional send renders the new copy. Brevo's own docs add a caveat worth knowing: update a Drag & Drop template's HTML through the API and that template loses Drag & Drop editor access. And Brevo's general API tier caps most endpoints outside sending at 100 requests an hour, so a read-then-write loop over 80 templates makes 160 calls and stalls at the cap with most of an hour to wait.
Scratch
Scratch keeps the script route's reach and gives the library the review it needs. Your 80 templates become files on your laptop. The agent greps, scores, and rewrites; you read each change as a word-level diff, the braces of every merge tag visibly untouched next to the original. A validator, if you set one, fails any rewrite that changes the merge-tag count or loses the unsubscribe block before you read a single diff. Subject, body, sender, reply-to, active status, and template tags are the editable surface. Nothing publishes until you approve it, and an approved template can be reverted per item afterward. The cost is stated plainly: reviewing 80 diffs is real reading, on purpose.
| Option | Whole library | AI judgment | Review before live | Undo after publish |
|---|---|---|---|---|
| One template at a time | No | Aura, per template | You are the editor | Version history, per template |
| Duplicate and rebuild | No | No | The duplicate is the preview | Keep the original, repoint by hand |
| Chatbot copy-paste | One paste at a time | Yes | Eyeballing pasted HTML | No |
| Scripts on the API | Yes | Yes, if wired in | Only if you build it | No |
| Scratch | Yes | Yes, your agent | Every change, as a diff | Per template, even after publish |
How the loop works on your template library
- Scratch pulls your templates into files. Every template in the library lands as its own file on your laptop: subject, HTML body, sender, reply-to, active status, and tags, together in one place instead of two panes. Nothing in Brevo has changed. The whole library is now searchable: every template still carrying the old product name or the retired launch discount surfaces in one grep.
- Your AI runs the voice pass. Point Claude, Codex, Cursor, or Copilot at the folder with the brief. Rewrite every subject and body into the current voice. Treat anything inside double braces, every link, and the unsubscribe block as untouchable. Flag any template still offering the 20% launch discount instead of editing it. The agent can do what no endpoint offers: count the merge tags in each file before and after, cross-check every link target, index the subject lines and kill the duplicates. That is 99% of the job, and the agent holds no API key while doing it.
- You review every diff and publish. Each template comes back as a word-level diff, subject and body beside the original. Validators run first if you set them, so a rewrite that changed the merge-tag count or lost the unsubscribe block fails before you read a word. Subject lines are revenue; each one gets your eyes. Approve per template, and Scratch writes only those back through Brevo's API at the API's own pace, one approved template at a time. The last 1%, deciding what lands in inboxes, stays yours. Reject a published template and the previous copy goes back.
Run the first batch on 10 low-stakes templates. The welcome sequence goes last, after the validators have proven themselves on everything else.
What a template rewrite reaches, and what it does not
Brevo's plumbing deserves one honest paragraph. Transactional emails reference a template by ID, so the next send renders your new copy. Campaigns and automations are different: Brevo's docs describe campaigns copying only the design at creation, and the newer automation editor forks a template into its own message the moment you select it. Those existing forks keep their old copy no matter what happens to the library. A template rewrite is exactly what it sounds like: the library itself, governing transactional sends now and everything built from templates going forward. Messages already living inside automations are a separate cleanup, and Scratch does not edit automation steps. One more inheritance issue for old libraries: templates built in the classic editor, discontinued at the end of 2024, must be migrated to the new editor before they can be edited in Brevo.
Questions people ask
Can AI rewrite the copy without mangling merge tags?
It can. The proof has two layers. The first is the brief: anything inside double braces is untouchable. The second does not depend on the model behaving: a validator that compares the merge tags in each rewrite against the original and fails any template where they differ, before review. The diff itself is the third look, with {{ contact.FIRSTNAME }} sitting unchanged next to the original. Hope is not part of the design.
How do I find every template that still uses the old product name?
Grep. The templates are files, so one search across the folder returns every match in under a second, subject lines included. The agent can go further: build an index of which templates mention which offers and hand you the list before any rewriting starts. Brevo's UI today has no search across template content, which is why this question usually has no answer at all.
What happens if a rewrite drops the unsubscribe link?
Nothing good. For campaign templates, Brevo's help center describes restoring a default unsubscribe footer at send time, present but not yours. For transactional templates no footer is restored, and a recipient who cannot find the unsubscribe link reaches for the spam button instead, the complaint the major mailbox providers now threshold bulk senders on. This is the failure that costs a sender reputation, not just a brand guideline. It is also exactly what a validator is for: a rewrite missing the unsubscribe block fails before it reaches your review.
Can I read every subject line before it ships?
Yes. Each template's diff shows the subject and body together, so a subject change never hides in a settings pane. Nothing publishes until you approve that template. Subject lines deserve the attention: nothing in the library gets read more.
Can I update sender names and reply-to addresses in the same pass?
Yes. Subject, body, sender, reply-to, active status, and template tags are all fields in the same file, so standardizing the sender name across 80 templates is the same loop: edit, diff, approve. Contacts are a different job, and mailing lists stay read-only.
Will rewritten templates lose the Drag & Drop editor?
They can. Know it going in: Brevo's API docs warn that updating a Drag & Drop template's HTML through the API removes Drag & Drop editor access for that template. The warning applies to any tool that writes template HTML, Scratch included. A pass that changes only subjects writes no HTML and avoids it, because Scratch sends back only the fields you approved. A full body rewrite means future edits to those templates happen in HTML, or through another reviewed pass.
What does the AI read, and what leaves my laptop?
Nothing. On Scratch's side there is no built-in AI, and Scratch sends your templates to no model. The agent you already use reads the folder under your own account and plan, the way it reads any local folder. Which model sees your email copy stays your decision.
What does Scratch not touch in Brevo?
Sends and schedules. Scratch edits templates and contact data; it does not send email, schedule campaigns, or make any claim about deliverability or send-time behavior. Mailing lists are read-only, and messages inside automations are not part of the template library. If the field you need is not covered, tell Curtis.
See it on your own templates
The fastest way to trust the loop is to watch it run on your own archaeology. See it run on your Brevo templates →, or download Scratch free and pull your template library this afternoon; the first grep for the old product name takes under a minute. Scratch is free to try, and the AI is whichever agent you already pay for.