SEO Content Brief Research

The fastest way to ruin a content program with agents is to let them write the articles. The fastest way to improve one is to let them do the research a good editor used to do by hand: read what currently ranks for the query, work out what the searcher actually wants, map what competitors cover and miss, and collect the sources a writer can verify and cite.

That research is real work — an hour or two per brief when a person does it carefully, which is exactly why most briefs are a keyword and a word count instead. The writer then spends the first half of the draft reverse-engineering what the brief should have told them, and the SEO lead finds out at review time that the article answers a question nobody is asking.

This workflow keeps the division of labor explicit. Agents gather evidence about the search landscape and assemble it into a brief. The writer writes, with their own voice and judgment. The SEO lead decides which topics to pursue and what claims the company is willing to make. Nothing in the brief is a guarantee of ranking, because rankings are not something anyone can guarantee.

Use this workflow whenever a writer needs to produce content for a query the team has not personally studied: new topic clusters, comparison and alternative pages, help-center content with search demand, refreshes of pages that have slipped. It is a Foundation workflow on purpose — the agent roles are simple and the human checkpoints are obvious — which makes it a good first dynamic workflow for a marketing team.

Skip it for content where search is not the channel — announcement posts, opinion pieces, sales enablement — and for topics where the team's own expertise already exceeds anything the SERP can teach them. In that second case the brief writes itself from the inside out, not from the search results in.

• A new topic cluster where nobody on the team has studied the SERP.
• Comparison, alternative, and pricing-adjacent pages where structure matters as much as prose.
• A help-center or docs revamp where dozens of briefs are needed on a schedule.
• Refreshing pages that have lost positions, where the question is what changed around them.

This runs as a Claude Code dynamic workflow. Including the word workflow in the prompt makes Claude write a JavaScript orchestration script that runs subagents in the background; the raw page notes, intent classifications, and coverage maps stay in script variables and on disk rather than in Claude's context, and only the assembled brief comes back to the conversation. The script can run up to 16 agents concurrently and up to 1,000 per run, so a batch of a dozen briefs is one run, not twelve chats. Runs are resumable, and a working script saved to .claude/workflows/ (project) or ~/.claude/workflows/ (personal) becomes a reusable slash command.

The cross-check is the design decision that matters. The SERP agents report what ranking pages actually contain — structure, depth, format, freshness — while the intent agent classifies what the searcher wants independently, from the query and the kinds of results that appear, not from any single page. When the two disagree, that disagreement goes into the brief as a finding rather than being smoothed over: a SERP full of listicles for a query whose intent looks transactional is exactly the kind of gap a strategist wants to see.

Subagent definitions live in .claude/agents/*.md, and the research stage requires WebSearch. If the team already uses /deep-research — the bundled research workflow, which also requires WebSearch — this workflow is the specialized, brief-shaped cousin: same mechanics, narrower output. /effort ultracode is the explicit way to request the orchestration depth if the prompt alone does not trigger it.

The SERP agents take the target query and its close variants and study the pages that currently rank: how they are structured, how deep they go, what format they use, how fresh they are, and what they all seem to share. The findings stay observational — every ranking page includes a pricing table — rather than causal, because nobody outside the search engine knows why a page ranks.

The intent agent classifies what the searcher wants — informational, commercial investigation, transactional, navigational — and, more usefully, describes the situation the searcher is probably in and what would satisfy them. The coverage agent maps the subtopics and questions competitors answer, the ones they all skip, and the ones the People Also Ask boxes and forums suggest are unmet. The sources agent collects authoritative references the writer can actually cite: documentation, standards, primary research, first-party data the team owns.

The prompt below is what a content strategist pastes into Claude Code, with the query, the audience, and any first-party inputs — a Search Console export, the existing sitemap, the product positioning doc — placed in a briefs/inputs/ folder first. The word workflow triggers the background orchestration; WebSearch must be available for the research agents.

Run this as a workflow. WebSearch is required.

Target query: "crm migration checklist"
Audience: operations leads at 50-500 person companies planning a CRM switch.
Inputs: briefs/inputs/search-console-export.csv, briefs/inputs/sitemap.txt,
briefs/inputs/positioning.md.

Research stage (parallel agents):
- For the target query and 3-5 close variants, SERP agents study the pages that
  currently rank: structure (headings), depth, format, freshness, and what they
  share. Keep findings observational; cite URLs. Do not guess why pages rank.
- An intent agent classifies the search intent and describes the searcher's
  situation and what would satisfy them, independently of any single page.
- A coverage agent maps subtopics and questions competitors cover, skip, or
  answer badly, including People Also Ask style questions.
- A sources agent collects authoritative references the writer can cite, with
  one line each on why the source is trustworthy.

Assembly stage: cross-check the SERP and intent findings, flag disagreements,
and assemble briefs/output/crm-migration-checklist.md using
content-brief-template.md: audience, intent, recommended structure, questions
to answer, internal link candidates from the sitemap, sources, and success
measures. Do not write the article. Do not recommend keyword stuffing or any
tactic aimed at search engines rather than readers.

Claude writes the real script at run time; the sketch shows the shape. The per-query research results never enter the main conversation — they are awaited inside the script, written to disk, and only the assembled brief comes back for review.

// Sketch of the orchestration script Claude Code generates for this workflow.
import { readFile, writeFile } from "node:fs/promises"

const queries = ["crm migration checklist", "how to migrate crm data", "crm switch plan"]
const sitemap = await readFile("briefs/inputs/sitemap.txt", "utf8")

// Parallel research: SERP notes per query, plus intent, coverage, and sources
const [serpNotes, intent, coverage, sources] = await Promise.all([
  Promise.all(
    queries.map((q) =>
      agent(
        "Use the serp-researcher agent rules. Study the pages currently ranking for: " + q +
          ". Report structure, depth, format, freshness, and shared traits. Observational only; cite URLs.",
        { model: "sonnet" }
      )
    )
  ),
  agent("Use the intent-classifier agent rules for the query set: " + queries.join(", "), { model: "sonnet" }),
  agent("Use the coverage-mapper agent rules for: " + queries[0] + ". Map covered, missing, and badly answered subtopics.", { model: "sonnet" }),
  agent("Use the sources-collector agent rules for: " + queries[0] + ". Authoritative, citable references only.", { model: "sonnet" }),
])

await writeFile("briefs/research/serp-notes.md", serpNotes.join("\n\n---\n\n"))

// Cross-check and assemble; disagreements become findings, not casualties
const brief = await agent(
  "Assemble a content brief from the research below using content-brief-template.md.\n" +
    "Cross-check SERP findings against the intent classification and flag any disagreement.\n" +
    "Suggest internal links only from this sitemap:\n" + sitemap +
    "\n\nSERP notes:\n" + serpNotes.join("\n") + "\n\nIntent:\n" + intent +
    "\n\nCoverage:\n" + coverage + "\n\nSources:\n" + sources,
  { model: "opus" }
)
await writeFile("briefs/output/crm-migration-checklist.md", brief)

The agent definitions are short and mostly consist of restraint: stay observational, cite URLs, do not invent statistics, do not recommend tactics aimed at the search engine instead of the reader. The serp-researcher definition below is the one doing the most repetitive work; the intent, coverage, and sources agents follow the same pattern with different output sections.

---
name: serp-researcher
description: Studies the pages currently ranking for one query and reports what they contain. Observational only; never speculates about ranking factors or recommends manipulation.
tools: WebSearch, Read, Write
---

You research what currently ranks for one query.

Rules:
- Search the query and read the top organic results you can access.
- For each page, note: URL, page type (guide, comparison, listicle, docs, tool),
  heading structure, approximate depth, notable elements (tables, calculators,
  templates, videos), and last-updated signals.
- Then summarize what the ranking pages share and where they differ.
- Stay observational: write "every ranking page includes a pricing table",
  never "adding a pricing table will make this page rank".
- Do not invent statistics, traffic numbers, or dates you did not see.
- Do not recommend keyword density targets, hidden text, doorway pages, or any
  tactic aimed at search engines rather than readers.
- Output markdown with one section per page and a final shared-traits section.

The brief is a one-to-two page markdown document. Everything in it must trace back to the research files or the team's own inputs; the assembler is told to leave a section thin rather than pad it. Success measures are framed as things the team can observe — coverage of the agreed questions, citations earned, assisted conversions, position movement over time — not as promised rankings.

# Content brief: <working title>

## Target query and variants
<primary query, close variants, and the Search Console queries this page should serve>

## Audience
<who is searching, what situation they are in, what they already know>

## Search intent
<classification plus a plain-language statement of what would satisfy this searcher;
note any disagreement between intent and what the SERP currently rewards>

## What currently ranks (observational)
<3-6 bullets on what ranking pages share: structure, depth, format, freshness — with URLs>

## Recommended structure
<proposed H2/H3 outline with one line per section on what it must accomplish>

## Questions this page must answer
<from the coverage agent: covered-by-everyone questions plus the gaps worth owning>

## What not to do
<topics to avoid, claims that need approval, anti-patterns from the editorial standards>

## Sources the writer can cite
<authoritative references with one line on why each is trustworthy>

## Internal links
<existing pages to link to and from, taken from the sitemap only>

## Success measures
<observable measures: questions covered, sources cited, engagement, position trend
over 90 days — rankings are not guaranteed and this brief does not promise them>

## Open questions for the SEO lead and writer
<anything the research could not settle>

You need Claude Code with WebSearch available, a folder for inputs and outputs, and ideally a Search Console export and a sitemap so the internal-link suggestions come from pages that exist. The first run on a single query is the right way to calibrate before batching.

• Create briefs/inputs/ and add what you have: a Search Console export, the sitemap, positioning or messaging docs, editorial standards.
• Copy the agent definitions from the code repository into .claude/agents/ and content-brief-template.md into the project root.
• Pick one query and paste the workflow prompt; review the research files as well as the brief on the first run.
• Check the brief against the template: every claim about the SERP should carry a URL, every internal link should exist in the sitemap.
• Have the SEO lead confirm the intent call and the success measures; have the writer mark what is missing before they start drafting.
• Once the single-query run is trustworthy, batch: list the queries in a file and let the workflow loop over them in one run.
• Save the script to .claude/workflows/ as a command so producing a brief becomes a routine task rather than a project.

A B2B SaaS team briefed a comparison page against their main competitor. The SERP agents found that all eight ranking pages for the query family shared two elements the team had not planned: a pricing comparison table near the top and a dedicated migration section. Three of the eight also included a feature-by-feature table maintained with visible update dates.

The brief recorded those as observations with URLs, and the recommended structure included both elements — plus a gap the coverage agent flagged: none of the ranking pages addressed data residency, which the team's own sales calls said was a deciding factor for their segment. The writer kept their own voice and argument; the page simply did not skip the sections every searcher apparently expected, and it owned the question nobody else answered.

An agency revamping a client's help center needed briefs for twelve high-traffic support topics in one week. Run as a single batch workflow, the research and assembly took an afternoon of machine time and roughly four hours of human review across the SEO lead and two writers — against an estimated three to four days had the strategist researched each topic by hand.

The review still mattered. Two of the twelve briefs came back with intent calls the SEO lead overruled — the SERP rewarded long guides, but the support data showed users arriving mid-task who needed an answer in the first paragraph — and one brief was discarded because the topic belonged in product documentation, not marketing-owned content. Ten usable briefs out of twelve, with the two corrections caught at review rather than after publication, was the outcome the agency considered the actual win.

For one developer-tooling query, the SERP agents found that the top results were largely written in 2022 and described a setup process two major versions out of date; the freshest ranking page was a forum thread complaining about exactly that. The coverage agent's gap list was unusually short, because the gap was the whole topic: a current, hands-on guide reflecting the present version.

The brief said so plainly, recommended a structure built around the current workflow with a clearly dated compatibility note, and listed the official changelog and migration docs as primary sources. It also stated the limit honestly: an outdated SERP is an opportunity signal, not a promise, and the success measure was framed as position trend over 90 days alongside whether developer readers actually completed the setup the page described.

The test of a brief is whether the writer starts drafting instead of starting their own research, and whether the SEO lead can defend every recommendation by pointing at evidence rather than convention.

The workflow observes the search landscape; it does not control it. Nobody — agent, agency, or tool — can guarantee a ranking, and a brief that implies otherwise is setting the writer up to be blamed for an algorithm. What ranking pages share is correlation the team can learn from, not a recipe.

The human calls stay human. The SEO lead decides which topics are worth pursuing and whether the intent call matches what the business knows about its customers. The writer owns the argument, the voice, and the expertise on the page. Legal or regulated claims go through whoever approves claims, not through a brief. And the durable strategy is the boring one: pages that are genuinely useful, original, and accurate tend to keep working after tactics stop, which is also what Google's own search documentation describes as the standard. This workflow never recommends keyword stuffing, doorway pages, or content produced primarily to manipulate rankings — that is both against the guidelines and a bad trade for the brand.

• It cannot guarantee rankings or traffic; success measures are observable trends, not promises.
• It cannot replace the writer's expertise or voice; a brief is scaffolding, not a script.
• It cannot approve product, legal, or competitive claims.
• It cannot see proprietary search data; pair it with Search Console exports and the team's own analytics.
• It will not recommend spam tactics, and a team that wants them should not expect this workflow to provide cover.

Save the script to .claude/workflows/ and the agents to .claude/agents/, and the brief becomes the cheap, well-evidenced start of every piece of search content the team produces.

1. Pick the target query, the audience, and gather inputs: Search Console export, sitemap, positioning, editorial standards.
2. Run SERP agents over the query and its close variants; record observational findings with URLs.
3. Run the intent agent independently; describe the searcher's situation and what would satisfy them.
4. Run the coverage agent: questions competitors answer, skip, or answer badly.
5. Run the sources agent: authoritative references the writer can verify and cite.
6. Cross-check SERP and intent findings; flag disagreements as findings in the brief.
7. Assemble the brief from the template: audience, intent, structure, questions, internal links, sources, success measures.
8. The SEO lead and the writer review, correct, and own everything that follows.