Comparison, alternatives and segment pages

The last page a buyer reads before deciding. Someone searching "X vs Y" or "alternatives to X" has already accepted the category and is choosing a supplier: the highest-intent pages a site can own, and the format AI assistants reach for when asked to recommend, because a page that compares and concludes is directly usable as an answer.

Two rules make or break the category. The comparison must be verifiably true on the day it is published, and it must concede where a competitor genuinely wins. A page that wins every row, or that states last year's facts, is discounted by readers and by models alike.

Company knowledge first (Obsidian)

If the working environment contains an Obsidian vault or any local knowledge base (a folder of .md notes, often with a .obsidian directory), read it before writing: the real feature set, real pricing, the competitors that actually come up in sales calls, the objections buyers raise, and the segments the business already serves. Comparison pages assert facts about third parties, so unsourced invention is both a credibility and a legal risk. Log the pages produced to the vault's SEO action log, including the date each comparison was verified, since that date drives the refresh cycle.

When to use

• Planning, auditing or writing a "X vs Y", "alternatives to X", "best X for Y", comparison hub or segment page.
• Competitors, review sites or affiliates rank for "{your brand} alternatives" and you do not.
• ChatGPT, Perplexity or AI Overviews recommend competitors on comparison prompts.
• A product serves several distinct customer types and the site has one generic page for all of them.
• A category page exists but never concludes, so it converts nothing.
• An existing comparison page is more than a quarter old, or a competitor changed its pricing or shipped a feature.

Phase 1. The spec

Common requirements C-01 to C-27: skills/seo-geo-audit/references/common-page-spec.md

The rows below are what a comparison or segment page adds on top of them. Thresholds are field heuristics from agency audits unless marked measured. Levels follow seo-page-sections/references/page-type-matrix.md sections 5 and 6: every row is required unless its Threshold says "recommended" or "optional".

Comparison, alternatives, best-for and hub pages (section_audit.py --type comparison)

Audience and segment pages (section_audit.py --type audience)

Phase 2. Audit the existing page

Skip this phase when no page exists yet; Phase 3 then sets the bar for the build.

1. Inventory first. List every page that already targets a comparison term: Search Console queries containing "vs", "versus", "alternative", "compare", "for {segment}", and a site: search. Two URLs for one comparison, or a segment page and the main product page ranking alternately, fail CMP-01 or CMP-29 before any copy is read.
2. Run the two collectors on each page:

python3 skills/seo-geo-audit/scripts/seo_audit.py https://example.com/you-vs-competitor/ /competitor-alternatives/
python3 skills/seo-page-sections/scripts/section_audit.py --type comparison https://example.com/you-vs-competitor/
python3 skills/seo-page-sections/scripts/section_audit.py --type audience https://example.com/for-agencies/

3. Map the output to the spec. Each seo_audit.py finding code fails the C row or CMP row that lists it in "Verified by"; each section_audit.py block marked missing fails its CMP row (verdict_block CMP-04 and CMP-10, comparison_table CMP-05, price_in_text CMP-09, freshness_signal CMP-14, author_block CMP-15, faq CMP-16 and CMP-37, process_block CMP-33, social_proof_logos and reviews CMP-34). keyword_stuffing on a competitor name is usually the comparison itself: judge before rewriting.
4. Do the manual rows. The scripts cannot judge truth, so open each competitor's public pricing page, docs and changelog and check every row of the table (CMP-12): a price, a limit or a "lacks feature X" that is no longer true fails the page. Read the verification date (CMP-14), look for the row a competitor wins (CMP-07), the limitations block (CMP-08) and the legal conditions (CMP-22). For segment pages, read the sibling pages side by side for the non-duplication test (CMP-31).
5. Mark every C row and every CMP row Pass, Fail or Not verifiable, with the evidence (finding code, block, URL of the source checked).

A page that ranks and converts is fixed in place: keep the URL (CMP-02), re-verify, update the date. Rebuilding from scratch throws away accumulated signals.

Phase 3. Benchmark the competitors

For a comparison page, the competitors are not your business rivals' homepages: they are the pages that already rank, and that AI assistants cite, on the exact comparison query.

1. Pick 3-5 pages from the SERP of the target query ("{you} vs {competitor}", "{competitor} alternatives", "best {category} for {use case}", "{category} for {segment}") and from the answers ChatGPT, Perplexity and AI Overviews give to the same prompt. Mix the types that show up: review platforms and software directories, affiliate and editorial listicles, and the competitors' own vs and alternatives pages, including the page a competitor wrote about you ("{competitor} vs {you}", "{you} alternatives" on their domain). AI Mode and the organic top 10 share about a third of their URLs (32 percent overlap, measured by Semrush), so the cited pages matter as much as the ranked ones.
2. Run the benchmark:

python3 skills/seo-geo-audit/scripts/page_benchmark.py --type comparison https://example.com/you-vs-competitor/ https://competitor.com/competitor-vs-you/ https://review-site.com/you-vs-competitor https://publisher.com/best-category-tools/
python3 skills/seo-geo-audit/scripts/page_benchmark.py --type audience https://example.com/for-agencies/ https://rival.com/agencies/ https://rival2.com/solutions/agencies/

3. Read the output in this order:
   • Blocks half or more of the competitors have and the client does not (comparison_table, verdict_block, price_in_text, faq, author_block, freshness_signal): each is a CMP row moving to the top of the build.
   • Schema types competitors use and the client does not (often FAQPage, ItemList, Review on review platforms): adopt only what the page will truly show (CMP-27).
   • Metrics below the competitor median (words, tables, statistics, question_h, bold, placement, money_links): the C rows they map to move up in priority.
4. Read the competitor pages yourself for what the script cannot see:
   • The criteria they compare: their union is the candidate list for CMP-06, before you score anything.
   • Their facts and dates: a stale price or a "lacks feature" claim about the client is both an opening (be the current page) and something to correct, on your own page, with a source, never with denigration.
   • Whether they concede any row, state limitations or show a methodology: most do not, which is the gap.
   • The reasons for leaving they cite and the review quotes they use (CMP-23).
   • What the AI answers say about the client and on which source they lean (geo-visibility).
5. Define the information gain: what the page will contain that none of the ranking pages has. Candidates only the client can provide: hands-on test results with numbers, a migration guide with real time and cost, a total cost of ownership calculation including setup and overage, a fresher verification date, real screenshots, the uncomfortable FAQ answered, per-segment verdicts, quotes from customers who switched. Write it down in one line; the build must deliver it.

Phase 4. Build

Step 1. Decide which pages deserve to exist (CMP-01, CMP-02, CMP-29)

Do not build one page per competitor by default. Build the pages the market actually searches, then let the rest be sections inside them.

Mapping rules:

1. One comparison, one URL. "X vs Y" and "Y vs X" are the same page; pick one URL and be consistent everywhere. Do not create both.
2. Do not build a head-to-head page for a competitor nobody searches. Make it a row in the alternatives page instead.
3. "{competitor} alternatives" pages outperform "{you} vs {competitor}" pages for a challenger brand (field heuristic), because the searcher has already decided to leave the competitor and is open, rather than defending a preference.
4. Own "{your brand} alternatives". Someone will rank for it; it should be you, with your migration path one click away.
5. Segment pages must differ by more than find and replace (CMP-29, CMP-31). If not, merge them.
6. Keep the URL literal and stable (CMP-02).

Verify the demand with seo-keyword-research before committing, and check which existing page already ranks for the term to avoid cannibalizing it.

Step 2. Gather verifiable facts (CMP-09, CMP-12, CMP-14)

Every claim about a third party must be checkable on that third party's own public material, on the day you write it.

Record, per row, the source URL and the date verified. That log becomes the methodology block (CMP-13) and the input to the refresh cycle. If a fact cannot be verified, write "not published" in the cell: an honest gap reads as rigor, a wrong guess destroys the page. For anything disputable, quote and link the competitor's own words rather than paraphrasing. Client facts nobody confirmed stay {to confirm}.

Step 3. Choose the criteria and build the table (CMP-05, CMP-06, CMP-07, CMP-19)

Read references/comparison-page-patterns.md now. It carries the criteria-selection method, the fill-in wireframe of every family, the verdict formulas, the segment structure and the pre-publish checklist.

Choose 6-12 criteria from what buyers decide on (sales calls, support tickets, review sites, the benchmark's union of criteria), order them by influence, and only then fill in the values. If you win every row, the criteria are wrong: add the dimensions buyers raise when they choose someone else. The table is a real <table>, same criteria in the same order for every option, prices as text, a "Verified {date} from {sources}" line under it.

Step 4. Write the verdict (CMP-04, CMP-10)

Who each option is for, stated plainly, in the first 100 words, then repeated at the end. Use the formula that fits the family (routing for alternatives, situational for head-to-head, single winner for best-for, honest exit when neither fits): name names, use a concrete situation rather than an adjective, put a number in it where possible, and never resolve every case to your own product. Write it last and rewrite it twice: it is the passage that gets quoted.

Step 5. Write the page, block by block

Follow the family wireframe in the reference; the block list, levels and order also live in seo-page-sections/references/page-type-matrix.md, sections 5 and 6. Non-negotiables, each tied to its row:

1. Verdict in the first 100 words (CMP-04).
2. A real HTML comparison table (CMP-05), criteria chosen before scoring (CMP-06).
3. At least one row where a competitor genuinely wins, stated without hedging (CMP-07): the reason a model treats the page as a source rather than as marketing.
4. Your own limitations, in your own words, in a named block (CMP-08).
5. Pricing as HTML text with the date checked, for every option, like plan against like plan (CMP-09).
6. Best-for verdicts per use case (CMP-10): one page then answers "best for solo", "best for teams", "best on a budget".
7. Methodology and date: what was compared, how, when, by whom (CMP-13, CMP-14).
8. FAQ with the uncomfortable questions (CMP-16), migration section where switching is the intent (CMP-17).
9. Author block with credentials and real profiles (CMP-15).

Copy rules:

• Semantic bolding (CMP-25, C-09): the comparison term bold once in the first paragraph; then one bold phrase every 100-150 words on a deciding difference, a price or a verdict fact; never whole sentences, never decoration.
• Placement (CMP-25, C-10): the comparison term in the title, H1, first 100 words, at least two H2s, the meta description, the slug and one image alt, aiming at 60%+ coverage.
• Density (CMP-25, C-11): no term above 2.5% of content words; competitor and brand names aside, but do not repeat "X vs Y" in every heading.
• Numbers with sources (C-14): prices, limits, test results, review counts, each attributed and dated.
• Question H2s (C-13) where a section answers a buyer question ("Is {competitor} cheaper than {you}?").
• Zero em dashes and en dashes (C-25). Never leave an em dash (U+2014) or an en dash (U+2013) in copy that goes live on a client site. Replace each with a comma; use a colon, a period or parentheses when a comma loses the sense. The em dash is the most recognizable tell of AI-written text, and a page whose whole value is being trusted over a competitor's marketing cannot afford to read as machine output. The rule covers the verdict, the table cells, the FAQ, the methodology block, the metadata and the schema strings; sweep for both characters before delivery. Hyphens in compound words and ranges written with "to" are untouched.

Step 6. Stay legal and stay honest (CMP-22, CMP-26)

Comparative advertising is lawful across the EU under Directive 2006/114/EC, and in most markets, but only under conditions that happen to match what makes a comparison page work: it must not be misleading, it must compare goods meeting the same needs, it must compare features that are material, relevant, verifiable and representative, and it must not denigrate the competitor or create confusion between brands. Check the rules of the market being written for before publishing.

• Compare like with like. Comparing your top plan against a competitor's free tier is both dishonest and outside the safe harbor.
• Every claim must be verifiable by a reader from public sources. Link them.
• Use the competitor's name and mark descriptively, to identify them, not in a way that suggests endorsement or affiliation. Do not use their logo as if it were a partnership.
• No denigration. State the difference, not a judgment of their competence.
• Do not misrepresent an old version as current. Date the comparison.
• If the comparison sits on an affiliate or review page, disclose the commercial relationship.
• No unsourced superlatives about yourself (C-24); results promises carry their disclaimer.

Step 7. Segment pages (CMP-29 to CMP-40)

Same product, one customer type. Before building a set, check each segment for distinct vocabulary, a distinct primary problem, distinct proof available and real search demand; segments that fail any of those become a section on the main page. Then follow Family 5 in the reference: the problem in the segment's own vocabulary in the first 100 words, benefits in the segment's units, the workflow block, proof from the same segment, the segment's own objection, its pricing, an FAQ in its vocabulary, a CTA phrased for it, cross-links to siblings. The workflow and proof blocks require talking to real customers rather than imagining them: without that material, the page should not exist yet.

Step 8. Schema and metadata (CMP-27, CMP-40)

BreadcrumbList on every one (C-19). The author is a Person with sameAs to real profiles (C-20). Every property filled or removed, never empty; nothing marked up that the page does not show, in particular no rating or review markup for a competitor or for yourself that the page does not display. Templates: seo-schema-markup.

Step 9. Acceptance test

Re-run the Phase 2 and Phase 3 commands on the staged or live page:

python3 skills/seo-geo-audit/scripts/seo_audit.py https://example.com/you-vs-competitor/
python3 skills/seo-page-sections/scripts/section_audit.py --type comparison https://example.com/you-vs-competitor/
python3 skills/seo-geo-audit/scripts/page_benchmark.py --type comparison https://example.com/you-vs-competitor/ {the same competitor URLs}

The page is done when: no high or critical finding; comparison_table, verdict_block, price_in_text, faq, author_block and freshness_signal (or the segment blocks for --type audience) all found; BOLD above zero with the comparison term among the samples; PLACEMENT 60% or more; no schema_none, schema_fields, social_placeholder or em_dashes; no block that half the competitors have still missing; word count at or above the competitor median; every CMP manual row checked (sources, competitor-wins row, limitations, legal, verification date logged in the vault). A remaining Fail is either fixed or a written owner decision.

Maintain, or take it down (CMP-14)

Comparison pages decay faster than any other page type, because they depend on facts you do not control. A page claiming a competitor lacks a feature they shipped last year is worse than no page: it is the first thing a competitor's sales team screenshots.

Put the verification date on the page and in the vault log. Keep the URL through every refresh (CMP-02).

GEO layer (CMP-04, CMP-07, CMP-08, CMP-12)

Honesty is the GEO mechanism here, not only the legal one. Models weight pages that state limitations and cite sources, and a page whose every row favors its author reads as promotional to a reader and to a retrieval system alike. Adding statistics, quotations and cited sources raised visibility in generative answers in a controlled study (Princeton GEO, KDD 2024, measured). The verdict in the first 100 words is the quotable passage; the dated, sourced table is the extractable one; both must be in the server HTML (C-21). Track the comparison prompts in geo-tracking: comparison pages are where AI citation share moves first and most visibly.

Deliverable

## 1. Spec scorecard
| ID | Requirement | Status (Pass / Fail / Not verifiable) | Evidence |
(every C row and every CMP row for the page family; segment rows only for segment pages)

## 2. Audit findings
(page inventory and cannibalization check; seo_audit.py scores and high or medium findings;
section_audit.py blocks; competitor facts found stale or wrong; or "new page")

## 3. Competitor benchmark
(the ranking and AI-cited pages chosen, page_benchmark.py table, blocks and schema types
the client lacks, metrics below the median, criteria union, the information gain chosen)

## 4. Build
(page plan: families, URLs and keywords; then per page: metadata, the copy block by block
with the bolding visible, the comparison table, the verification log (fact, source URL,
date), JSON-LD, internal links; placeholders {to confirm} for unverified facts)

## 5. Acceptance
(scripts re-run: remaining findings, each either fixed or a written owner decision;
next verification date)

Common mistakes

• Winning every row. The fastest way to lose the credibility the page exists to build.
• Never concluding. "It depends on your needs" forfeits the answer to whoever does conclude.
• Comparing on your strengths. Criteria must be chosen from what buyers decide on, before checking who wins.
• Building a page per competitor regardless of demand. Thin near-duplicate pages compete with each other and none of them ranks.
• Building both "X vs Y" and "Y vs X".
• Segment pages produced by find and replace. Same page, swapped noun, split signal, nothing ranks.
• Stale facts with no date. Undated comparison claims are unusable to a careful reader and to a model.
• Comparison as an image. The most extractable block on the page, rendered unextractable.
• Ignoring "{your brand} alternatives". Someone will own that page; it should be you.
• Benchmarking against the competitors' homepages instead of the comparison pages that rank on the query.
• Rebuilding or moving a ranking comparison page instead of re-verifying it in place.
• Bolding whole table rows or the competitor's name everywhere: bold is for the deciding facts.

Sources

• Directive 2006/114/EC on misleading and comparative advertising (conditions under which comparison is lawful in the EU): https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX%3A32006L0114
• Why ChatGPT cites pages (1.4M prompt study): https://ahrefs.com/blog/why-chatgpt-cites-pages/
• Generative Engine Optimization: statistics, quotations and citations raise visibility (controlled study, KDD 2024): https://arxiv.org/abs/2311.09735
• AI Mode versus top 10 organic overlap (32 percent URL overlap): https://www.semrush.com/blog/ai-mode-comparison-study/
• Google guidance on AI features and structured data: https://developers.google.com/search/docs/appearance/ai-features
• Google structured data policies (markup must match visible content): https://developers.google.com/search/docs/appearance/structured-data/sd-policies
• Common page spec C-01 to C-27 and the script finding codes: skills/seo-geo-audit/references/common-page-spec.md, skills/seo-geo-audit/references/audit-checklist.md section 15.
• Criteria counts, 100-word verdict, quarterly refresh, bold cadence, challenger heuristic: field heuristics from agency audits, not Google statements.