The editorial voice spec that keeps AI copy on-brand at scale

When we started shipping AI-generated copy at volume, the failure was not bad writing. It was sameness. Twelve articles a week, six platforms each, and every other paragraph reaching for the same four words. The reader cannot name what is wrong, but they feel the churn. They stop trusting the byline. So we stopped treating brand voice as a vibe a writer carries in their head and started treating it as a spec a machine can check.

This is how we wrote that spec, what is in it, and how the gate runs on every single draft before a human ever sees it.

Voice is a contract you can enforce

Most brand guidelines read like poetry. "Be bold but warm. Confident but human." None of that survives contact with an LLM, because none of it is testable. An agent cannot grep for "warm."

We rewrote our voice as a set of hard rules, each one a thing a script can verify. There are three layers. A forbidden-words list. A pattern ban. And a set of positive constraints on length and stance. Everything in the spec is either a string match or a structural check. If a rule cannot be enforced by code, it does not go in the spec. It goes in the style notes humans read, which is a different document with no teeth.

The spec lives in version control as a flat file. Every agent that writes copy reads it at the top of its run. The gate reads the same file. One source, no drift between what we ask for and what we check.

The forbidden-words list

The list is short on purpose. Right now it holds about a dozen entries: the words and phrases that signal AI authorship to anyone who reads a lot of marketing copy. The verbs that promise without saying anything. The superlatives that every brand reaches for, which means no brand owns them.

We do not block these because they are grammatically wrong. We block them because they are crowded. When a word appears in ten thousand other landing pages this quarter, using it makes us sound like everyone else, and sounding like everyone else is the one thing a brand cannot afford.

The list also catches a few formatting tics. The em-dash, for one. LLMs love the em-dash. It is the punctuation of a model hedging between two clauses. We replace every one with a period or a comma, and the prose tightens immediately. The gate flags any em-dash as a hard fail.

Each entry has a reason field attached. When the gate rejects a draft, it tells the agent which word tripped it and why, so the rewrite is targeted instead of a blind reroll. That single detail cut our average rewrites per article from four to a little over one.

The pattern ban

Words are the easy half. The harder failure is structural. Models fall into a small set of rhetorical shapes that read as fluent on the first pass and as formula by the third article.

The one we fight hardest is the two-clause mirror. "Tools wait. Systems run." "We do not sell software. We sell outcomes." It feels punchy in isolation. Stacked across a feed it reads like a machine doing impressions of a copywriter. We ban the contrastive frame in all its forms: the "X, not Y" construction, the "X over Y" construction, and the short mirrored couplet.

Detecting these is harder than a string match, so the gate uses two passes. A regex layer catches the obvious syntactic forms. A lightweight classifier prompt catches the rest, scoring each paragraph for formula density and flagging anything over threshold. The classifier is cheap, a single short call, and it runs on every draft regardless of length.

The positive constraints

A spec made only of bans produces timid copy. The writer learns what it cannot do and plays safe. So the third layer of the spec is a short set of things every draft must contain, and these are checkable too.

The rules we hold every brand to: at least one concrete number or named artifact per 250 words, because vague copy reads as filler and a model left unconstrained defaults to vague. First-person plural voice, which the gate checks by counting first-person singular pronouns and flagging anything that drifts into the lone-expert register the brand does not use. A length band, currently 1300 to 1600 words for long-form, enforced as a hard range rather than a suggestion. And a stance check: the opening 120 words must make a claim, not warm up. We flag any draft that spends its first paragraph restating the headline.

The number rule is the one that does the most work. When we made specificity mandatory, the average draft picked up real detail on its own, because the writer now has to go find a figure or an example to clear the bar. Forcing a concrete anchor every few paragraphs is the cheapest quality lever in the whole spec.

How the gate runs

The gate sits between generation and publish. No draft skips it, including ones a senior operator wrote by hand, because we want the standard to be the standard for everyone.

The sequence is plain. An agent produces a draft. The gate loads the spec file, runs the forbidden-words scan, runs the em-dash check, runs the regex pattern pass, then runs the classifier pass. Each failure returns a structured object: the rule, the offending span, and the reason. If the draft is clean it moves to the human queue. If it fails, the violations go back to the writing agent as the next prompt, and it rewrites only the flagged spans.

We cap the loop at three attempts. If a draft cannot pass in three tries, it escalates to a person, because a draft that stubborn usually has a deeper problem than word choice. In practice that happens on maybe one article in thirty.

The whole gate adds about two seconds and a fraction of a cent per draft. Against the cost of one off-brand article reaching the feed, that is nothing.

What it bought us

One concrete example. Last quarter we ran a batch of 60 articles through the system for a client in B2B fintech. Before the gate, our spot checks caught off-brand language in roughly one draft in three, and the misses that slipped through were the expensive kind, the ones a prospect reads and quietly files under generic. After the gate went live, the human review pass stopped being a copyedit and became a judgment call about ideas, because the mechanical problems were already gone. Review time per article dropped by about half.

The deeper win is that the spec is now an asset. When we onboard a new client we fork the file, swap the forbidden list for their crowded words, adjust the length bounds, and the gate enforces their voice from the first draft. Voice stops being tribal knowledge that lives in one editor's head and becomes a thing we can hand off, audit, and improve.

Keeping the spec alive

A voice spec is not a document you write once. The crowded words change. The phrase that signaled effort in January reads as cliche by June, because the rest of the internet caught up to it. So we treat the spec as a living file with an owner and a review cadence.

Every month we pull the drafts the gate flagged most often and read them. If a rule is firing constantly on legitimate copy, it is too broad and we tighten it. If a new tic is showing up in human review that the gate missed, we add a rule for it. The forbidden list has turned over roughly a third of its entries since we started, while the structural bans have stayed stable, because rhetorical formula is more durable than vocabulary fashion.

We also log every gate decision with the rule that fired and the eventual human verdict. That log is how we tell a good rule from a noisy one. A rule that fails drafts the human would also have rejected is earning its place. A rule that fails drafts the human then waves through is friction with no payoff, and we cut it. After a year of this the false-positive rate on our core ruleset sits low enough that the writing agents rarely fight the gate, which is the sign the spec has converged on the actual voice rather than a caricature of it.

We run this gate across every brand we operate, including the 83 agents inside our own stack. If you are generating copy at any real volume and relying on taste alone to keep it on-brand, you will lose, because taste does not scale and attention runs out. A spec does scale. Write the rules down, make them checkable, and put a gate in front of publish. That is the whole trick.