Seo Content Brief

Automate and integrate SEO content brief creation for targeted, optimized writing

Category: content-creation Source: inference-sh-9/skills

SEO Content Brief is a community skill for creating structured content briefs optimized for search, covering keyword targeting, competitor analysis, content outlines, search intent mapping, and optimization guidelines for content writers.

What Is This?

Overview

SEO Content Brief provides tools for generating detailed content creation instructions that align with search engine optimization goals. It covers keyword targeting that selects primary and secondary terms based on volume and difficulty, competitor analysis that reviews top-ranking pages to identify content gaps and coverage requirements, content outlines that structure headings and sections based on topic coverage analysis, search intent mapping that aligns content format and depth with what users expect for each query, and optimization guidelines that specify meta tags, word counts, and linking targets. The skill helps teams produce search-optimized content.

Who Should Use This

This skill serves content strategists planning editorial calendars, SEO managers directing content production, and writers creating articles optimized for specific search queries.

Why Use It?

Problems It Solves

Content written without keyword research misses search demand and fails to attract organic traffic. Writers without SEO briefs produce articles that lack the depth and structure needed to compete in search results. Inconsistent content quality across writers leads to uneven SEO performance. Ad hoc content creation without competitor analysis leaves gaps that top-ranking pages already cover.

Core Highlights

Keyword selector identifies primary and secondary targets by volume and difficulty. Competitor analyzer reviews top results for coverage gaps. Outline builder structures content headings from topic analysis. Intent mapper aligns content format with user search expectations.

How to Use It?

Basic Usage

from dataclasses import (
  dataclass, field)

@dataclass
class Keyword:
  term: str
  volume: int
  difficulty: int
  intent: str

@dataclass
class ContentBrief:
  title: str
  primary_kw: Keyword
  secondary_kws: list[
    Keyword] = field(
      default_factory=list)
  headings: list[
    str] = field(
      default_factory=list)
  word_count: int = 1500
  meta_desc: str = ''

class BriefBuilder:
  def __init__(
    self,
    primary: Keyword
  ):
    self.brief = (
      ContentBrief(
        title='',
        primary_kw=
          primary))

  def set_title(
    self, title: str
  ):
    self.brief.title = (
      title)
    return self

  def add_keyword(
    self, kw: Keyword
  ):
    self.brief\
      .secondary_kws\
      .append(kw)
    return self

  def add_heading(
    self, heading: str
  ):
    self.brief.headings\
      .append(heading)
    return self

  def build(
    self
  ) -> ContentBrief:
    return self.brief

brief = (
  BriefBuilder(
    Keyword(
      'python tutorial',
      5000, 45,
      'informational'))
  .set_title(
    'Python Tutorial '
    'for Beginners')
  .add_heading(
    'Getting Started')
  .add_heading(
    'Basic Syntax')
  .build())
print(brief.title)

Real-World Examples

import re
from collections import (
  Counter)

class CompetitorAnalyzer:
  def __init__(self):
    self.pages = []

  def add_page(
    self,
    url: str,
    html: str
  ):
    headings = re.findall(
      r'<h[1-3][^>]*>'
      r'(.*?)</h[1-3]>',
      html)
    word_count = len(
      re.sub(
        r'<[^>]+>', '',
        html).split())
    self.pages.append({
      'url': url,
      'headings':
        headings,
      'words':
        word_count})

  def common_topics(
    self
  ) -> list:
    all_headings = []
    for p in self.pages:
      all_headings.extend(
        h.lower().strip()
        for h in
        p['headings'])
    counts = Counter(
      all_headings)
    return [
      {'topic': t,
       'frequency': c}
      for t, c in
      counts.most_common(
        10)]

  def avg_length(
    self
  ) -> int:
    if not self.pages:
      return 0
    return sum(
      p['words']
      for p in
      self.pages
    ) // len(self.pages)

analyzer = (
  CompetitorAnalyzer())
analyzer.add_page(
  'https://ex.com/a',
  competitor_html_1)
analyzer.add_page(
  'https://ex.com/b',
  competitor_html_2)
print(
  f'Target length: '
  f'{analyzer.avg_length()}'
  f' words')
for t in (
  analyzer
  .common_topics()[:5]
):
  print(
    f'  {t["topic"]}: '
    f'{t["frequency"]}x')

Advanced Tips

Analyze the search results page layout to determine if the query favors long-form guides, listicles, or comparison tables. Include internal linking targets in briefs to strengthen topical authority across the site. Specify unique angles or data points that differentiate content from existing top results.

When to Use It?

Use Cases

Create a detailed brief for a product comparison article targeting a commercial intent keyword. Generate content outlines based on competitor heading analysis for comprehensive topic coverage. Build an editorial calendar with briefs mapped to keyword clusters and search intent categories.

Important Notes

Requirements

Keyword research data including search volume and difficulty scores. Access to competitor content for top-ranking analysis. Understanding of search intent categories for proper content alignment.

Usage Recommendations

Do: include both primary and secondary keywords in each brief with specific placement guidance. Analyze at least three to five competitor pages to identify comprehensive content requirements. Specify the target search intent and align content format accordingly.

Don't: create briefs without reviewing what currently ranks since search results reveal user expectations. Focus exclusively on keyword density rather than comprehensive topic coverage. Produce briefs that are so prescriptive they prevent writers from adding unique value.

Limitations

Content briefs based on competitor analysis may converge toward similar content that lacks differentiation. Search intent can be ambiguous for some queries making it difficult to choose the right content format. Keyword data provides estimates and actual traffic may differ from projected volumes.