SEO Content Brief: How to Brief Writers (and AI) So Pages Rank

Brief the ranking job, not the topic

Ask AI

The brief’s first move is to name the ranking job so tightly that a writer—or a model—cannot wander into a sibling URL’s lane. That job is the single SERP task this page must win. It has three parts: the query class (what kind of search this is), the searcher outcome (what “done” looks like for the person who clicked), and the comparison set (which pages this URL must actually beat, not a vague “cover the topic” wish).

Keyword-plus-outline briefs fail that test. They list a head term, a word count, and H2s that look like every other page in the cluster. Word counts stay healthy; uniqueness does not. Two URLs get the same “what is / how it works / benefits / FAQs” skeleton, swap a modifier, and cannibalize each other. Search engines treat them as near-duplicates because they were briefed as the same job with different labels.

Name the jobs this URL owns—and the ones it must refuse

Every brief should state three fences in plain language: the primary job this URL must win, the secondary job it may support without taking over, and the jobs it must leave to other URLs. That refuse list is exclusion, not the uniqueness slot; without it, AI and humans fill the page with adjacent intent because the outline invited it.

A topic brief says “cover CRM software.” A job brief says “help a mid-market ops lead choose a CRM by integration constraint.” The first invites a catalog. The second forces a decision path, a buyer, and a comparison set. Writers and models can still be fluent; they just cannot invent a different contract.

Turn the cluster map into one contract per URL

Once the ranking job is named, the next move is not a blank document. Start from the cluster map: every keyword group already belongs to a SERP family, and each family gets one URL and one job before anyone—human or model—writes a sentence. Assignment first, prose second. That is how you stop siblings from competing for the same outcome.

Hubs and children do different work. The parent URL frames the decision and navigates the category: what this class of product or problem is, who it is for, and which slices exist. Child URLs do not re-frame that decision. Each child owns a slice—attribute, location, use case, or persona—and answers only that slice’s searcher outcome. Mixing those jobs is how a “best CRM for agencies” page quietly becomes another generic CRM roundup.

That single-variable rule is what keeps children from colliding. If two children can change the same dimension, they will. If a generator is free to restate the category definition on every leaf, you get the same filler paragraph across the cluster and no page that actually ranks for its slice. The contract is the map plus the fences: this URL, this job, this variable, these invariants.

Write the exclusion fence before you write the outline

What keeps a contracted URL from drifting is not a prettier outline—it is an exclusion fence written first. Lead the brief with a do-not-cover list tied to sibling URLs, not a nice-to-have stack of H2s. If another page already owns “pricing by plan,” “implementation timeline,” or “industry-specific compliance,” this page must not rebuild those rooms. The fence is the contract made operational: one job, explicit leftovers, no accidental rewrite of the cluster.

Name the queries, entities, and objections this URL must deflect with a short handoff instead of a full answer. A mid-market ops lead who asks about Salesforce vs. HubSpot at the integration layer still needs a path to the comparison URL; they do not need a second comparison article nested inside this one. Spell the deflection in the brief: one or two sentences, the exact internal-link target, and the anchor intent (navigational, not “learn more”). Leftovers then become cluster glue—readers move, rankings stay distinct—rather than duplicate sections that cannibalize each other.

Call out SERP features this URL is not competing for so the page does not sprawl. If the cluster already fields a pricing table, a how-to sequence, or a local-pack play, this contract should say so in plain language: do not add a table, do not invent steps, do not fake locality. Writers and models fill space when the brief is silent; a fence that lists forbidden formats is cheaper than a rewrite after publish. Only after the exclusions, handoffs, and non-goals are locked should anyone sketch sections—because the outline then describes the remaining job, not the whole topic.

Lock uniqueness slots the model is not allowed to invent

Ask AI

With the fence already drawn, the brief still has to name what this URL uniquely owns—otherwise a model (or a rushed writer) will fill the hole with plausible filler that belongs on a sibling page.

Treat uniqueness as sourced slots, not style. Every ranking contract needs three filled fields the page cannot rank without: a named entity this URL is about (a product, integration, regulation, city, or plan—not a category), a differentiating attribute that is true here and false on the nearest sibling, and the constraint that makes this URL necessary (who it is for, what they cannot do without that attribute). If any of those three is blank, generation will invent a fourth “angle” and you will cannibalize yourself.

Proof the brief owner must supply

Ban invented statistics, fabricated case studies, and generic “benefits of” blocks. Mark in the brief which proofs are owner-supplied: quotes, screenshots, spec lines, pricing caveats, named customers who consented, or “none—keep qualitative.” Anything not in that list is out of bounds. AI should receive a closed list of allowed claims and a second list of claims reserved for other templates or sales pages (warranty language, ROI stories, competitor knockouts). If a claim is reserved, the model may hand off with a link; it may not paraphrase it into this URL.

Voice and reading level stay catalog-stable on purpose. Uniqueness comes from the slots above, not from a sudden shift into slang, hype, or academic register. Set bounds once—person, tense, reading level, banned flourishes—and reuse them so a cluster reads as one publisher, not a pile of random tones.

Ship one brief in two formats: editor narrative and generation fields

Once uniqueness is locked to facts the owner actually owns, the brief still has to travel. A ranking contract that lives only in a Slack thread or a pasted SERP dump will not survive a writer, a model, or a template. Ship the same contract twice: a short editor narrative for judgment, and a structured field set that generation cannot skip.

The editor copy is not an outline. It is a page of intent: who the audience is, the ranking job this URL must win, the angle that keeps it distinct from siblings, and the judgment calls a human still has to make—tone on a sensitive comparison, whether a feature belongs above the fold, when to hand off instead of expanding. That narrative is for the person who can say no.

Mirror every clause of that contract as named fields so AI and programmatic templates cannot treat fences as optional flavor. Job, reserved jobs, exclusion fence, uniqueness slots, allowed versus reserved claims, internal-link targets with anchor intent, and schema hints all sit as required inputs. If a field is empty, generation does not start. Pasting a SERP scrape into a prompt is not this: it copies the average of what already ranks, invites sameness, and skips the sibling fences that keep the cluster from cannibalizing itself.

Who owns which part of the contract

Ownership is explicit so the ranking job does not drift mid-sprint. The subject-matter owner fills uniqueness slots and supplies proof. The SEO or cluster owner writes and approves the exclusion fence and reserved jobs. Only that cluster owner may change the ranking job itself—never the writer, never the model, never a template default. Editors use the narrative to make the remaining calls; generation uses the fields to stay inside the fences.

Pass/fail tests that keep programmatic pages from going thin

Turn the ranking contract into tests a page either passes or fails before it ever goes live. A brief that cannot be scored is still an invitation to filler: unique slots left empty, fences quietly ignored, and neighbor URLs saying the same thing in slightly different words.

Score three gates first. The uniqueness slots must be filled with owner-supplied facts, not paraphrased benefits. The exclusion fence must hold: no section may answer a query reserved for a sibling. Overlap with neighbors must stay under a tight qualitative threshold—if a paragraph could sit on another URL in the cluster without a rewrite, it fails. Then require a self-contained answer block that does the ranking job in one place: a reader (or a citation) should be able to take that block alone and not need the intro from a sibling page.

Automatic rejects versus judgment fails

Some failures should never reach an editor. Missing named entity, numbers without an allowed source, a heading that answers a fenced query, or boilerplate that already lives on other URLs in the set—those are automatic rejects. Separate them from human fail states: ignored handoffs, padding to hit a word count, or a writer who “covers the topic” instead of the job. Model fail states look different: invented proof, drifted templates, or slots the system filled because the fields were blank. Treat those as generation bugs, not style notes. Until a draft clears the gates, it is not a ranking page; it is unfinished inventory.

Keep the ranking contract alive as generation scales

Pass/fail tests only hold if the contract stays in force after the first publish. Autoblogging is what you get when generation runs without that living contract: a keyword swap, the same H2 stack on every child, and uniqueness slots left empty so the model fills them with interchangeable filler. The URL still exists. The ranking job does not.

Scale the review, not the template. Parent hubs and money pages need a heavier cadence—someone re-reads the job, the fence, and the proof slots against live SERPs. Tightly variable children that still pass acceptance (one locked variable, filled slots, neighbor overlap held in check) can sit on a lighter loop. Volume is not a reason to skip the fence; it is a reason to make the fence cheaper to check.

A human must rewrite the ranking job—not just the copy—when the SERP for that URL shifts class, when a sibling starts winning the same query, or when proof slots go stale (retired SKU, dead integration, outdated constraint). Until that rewrite, generation is not allowed to “refresh” its way into a new job.

Treat the brief library as catalog ops. Version every contract. Retire jobs when the cluster map no longer assigns them a URL. Never ship a new generation template without the exclusion fence, uniqueness slots, and handoff links already filled. That is how one URL, one job survives automation instead of dissolving into a farm of near-duplicates.