Workflow

Step 1: Keyword mapping

Map each target page to a primary keyword, 2–3 secondary keywords, and a user-intent bucket (informational, navigational, transactional, commercial).

Step 2: Implement generateMetadata in Next.js

// app/blog/[slug]/page.tsx
import type { Metadata } from "next";
import { getPost } from "@/lib/posts";

type Props = { params: Promise<{ slug: string }> };

export async function generateMetadata({ params }: Props): Promise<Metadata> {
  const { slug } = await params;
  const post = await getPost(slug);
  if (!post) return {};

  return {
    title: `${post.title} | YourBrand`,
    description: post.excerpt.slice(0, 155),
    alternates: { canonical: `https://yourbrand.com/blog/${slug}` },
    openGraph: {
      title: post.title,
      description: post.excerpt.slice(0, 155),
      url: `https://yourbrand.com/blog/${slug}`,
      type: "article",
      images: [{ url: post.ogImage, width: 1200, height: 630 }],
    },
  };
}

Step 3: Entity gap analysis

1. Collect the top 10 SERP results for your primary keyword.
2. Extract named entities from each using an NLP tool or manual review.
3. Build a union set of entities and mark which ones your content covers.
4. Fill gaps with factual, sourced statements that naturally include missing entities.

Notes: for AI-organized surfaces (Web Guide, Gemini) pay special attention to topical clusters — label sections with concise H2s that match cluster subjects so the model can map your content into the correct group. Web Guide is a Search Labs experiment that groups links by topic using a custom Gemini model (Google blog: “Web Guide: An experimental AI-organized search results page”, Jul 24, 2025).

Step 4: JSON-LD structured data

Add application/ld+json script tags for the relevant schema type. Prefer the canonical terms from schema.org (see schema.org release listing for the current term set).

// components/article-jsonld.tsx
export function ArticleJsonLd({ post }: { post: Post }) {
  const schema = {
    "@context": "https://schema.org",
    "@type": "Article",
    headline: post.title,
    author: { "@type": "Person", name: post.author },
    datePublished: post.publishedAt,
    dateModified: post.updatedAt,
    image: post.ogImage,
    publisher: {
      "@type": "Organization",
      name: "YourBrand",
      logo: { "@type": "ImageObject", url: "https://yourbrand.com/logo.png" },
    },
  };
  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{ __html: JSON.stringify(schema) }}
    />
  );
}

Step 5: Set up llms.txt and llms-full.txt

llms.txt is a community spec used as a discovery aid for LLM-based crawlers. Follow the spec (https://llmstxt.org/) — structure the file as Markdown with an H1, a short blockquote summary, and H2-delimited file lists containing canonical URLs and short descriptions.

Practical rules:

• Place llms.txt at the site root. Keep the H1 and short blockquote summary concise.
• Use H2 sections with markdown lists of [name](url): short note entries to surface canonical sources.
• Do not attempt to use llms.txt as an access-control mechanism — use robots.txt for crawl directives.
• Maintain an llms-full.txt only if you understand caching implications; llms-full is useful when you want a snapshot of key content, but many crawlers will cache aggressively.

Minimal example (public/llms.txt):

# YourBrand

> YourBrand builds developer tools for X. Core docs and API below.

## Docs
- [Getting Started](https://yourbrand.com/docs/start): Quickstart and examples
- [API Reference](https://yourbrand.com/docs/api): Full API surface with examples

## Blog
- [How We Built X](https://yourbrand.com/blog/how-we-built-x): Engineering post with benchmarks

Node script: generate a simple llms-full.txt from your sitemap (example):

// scripts/generate-llms-full.js
const fs = require('fs');
const fetch = require('node-fetch');
(async function(){
  const sitemap = await fetch('https://yourbrand.com/sitemap.xml').then(r=>r.text());
  const urls = [...sitemap.matchAll(/<loc>(.*?)<\/loc>/g)].map(m=>m[1]);
  const lines = ['# YourBrand', '', '> Snapshot of key docs'];
  lines.push('');
  lines.push('## Snapshot');
  for(const u of urls.slice(0,200)){
    lines.push(`- [${u}](${u}): snapshot`);
  }
  fs.writeFileSync('public/llms-full.txt', lines.join('\n'));
})();

(See llmstxt.org for parsing expectations and recommended ordering.)

Step 6: Platform-specific GEO signals and a Web Guide tactic

Web Guide optimization tactic (short):

• Break long articles into clearly labeled H2 sections that mirror likely subtopics (e.g., “Symptoms”, “Diagnosis”, “Treatment” for medical queries).
• Add a 1–2 sentence lead at the top of each H2 that summarizes the section (makes it easier for clustering models to assign your section to a topic bucket).
• Ensure each section has at least one named entity, one authoritative link, and an internal canonical anchor so aggregators can reference the section directly.

Examples

Example 1: Blog post metadata in Next.js App Router

export async function generateMetadata({ params }: Props): Promise<Metadata> {
  const { slug } = await params;
  const post = await getPost(slug);
  return {
    title: post.title,
    description: post.excerpt.slice(0, 155),
    alternates: { canonical: `https://example.com/blog/${slug}` },
    openGraph: {
      title: post.title,
      description: post.excerpt,
      type: "article",
    },
  };
}

Example 2: Entity density improvement

Before: "Our tool helps with SEO." After: "Our tool analyzes Google Search Console data, identifies keyword cannibalization, and generates schema markup compliant with Schema.org Article and FAQ types."

Decision tree

• Page needs to rank in Google → apply full keyword placement workflow
• Page targets AI search only → focus on entity density + llms.txt + direct answers
• Page targets both → apply both workflows; JSON-LD and llms.txt are complementary
• Page is behind auth → skip SEO; focus on UX and internal search
• Content is thin (< 300 words) → expand with entity-rich paragraphs before optimizing

Edge cases and gotchas

1. Keyword stuffing penalties — Google penalizes unnatural repetition. Keep primary keyword density between 1–2%. Use semantic variants instead of exact repeats.
2. Duplicate metadata across pages — every page needs unique title and description. Use generateMetadata dynamically, never hardcode the same string.
3. JavaScript-rendered content — Google renders JS but some AI crawlers may not. Ensure SSR or SSG for all indexable content. Test with curl to verify immediate HTML output.
4. Canonical conflicts — a page with both a self-referencing canonical and a redirect will confuse crawlers. Pick one source of truth.
5. llms.txt freshness — AI crawlers cache aggressively. Update llms.txt and llms-full.txt when you publish or remove important pages, and include stable canonical links with update timestamps. Follow the llms.txt community spec for structure (https://llmstxt.org/).
6. Over-optimizing for one AI platform — each AI search engine weights signals differently. Optimize for the union of signals, not a single platform.
7. Search Console data anomalies and recent core updates — Google completed a March 2026 broad core update (rolled out over 12 days; see Search Status Dashboard and contemporaneous reporting). Wait at least a full week after a core update completes before drawing conclusions from traffic data; compare date ranges carefully.
8. AI fetcher bots and traffic siphoning — monitor server logs and analytics for non-browser AI fetcher traffic (reports in 2026 show a rise in AI bot traffic that can affect publisher referral traffic). Consider bot identification and rate limits when appropriate.

Evaluation criteria

• Every indexable page has a unique title, meta description, and canonical URL
• Primary keyword appears in title, H1, first 100 words, and at least one subheading
• JSON-LD is valid and uses current schema.org terms (validate against schema.org release notes)
• Entity coverage matches or exceeds top 3 SERP competitors
• llms.txt exists at the site root and follows the community spec (llmstxt.org)
• Page loads with SSR/SSG — content visible without JS execution
• Core Web Vitals pass (LCP < 2.5s, CLS < 0.1, INP < 200ms)
• No duplicate canonical URLs across the site
• Monitor Search Console and Search Status Dashboard for core updates and impression reporting corrections

Research-backed changes

The biggest delta since the last revision is adoption of AI-organized SERP experiments (Web Guide), a maturing llms.txt community spec, and ongoing core updates in early 2026. Fold the concrete changes into the operating notes and keep the workflow focused on verifiable signals.

Fresh signals

• Web Guide (Google Search Labs) — Google blog, Jul 24, 2025: Web Guide groups web links by topic and uses a custom Gemini model to organize results (https://blog.google/products-and-platforms/products/search/web-guide-labs/).
• llms.txt community spec — llmstxt.org: formalized guidance and parsing examples for llms.txt and llms-full.txt (https://llmstxt.org/).
• Schema.org releases — schema.org/docs/releases.html: authoritative release listing for schema.org terms and versions (https://schema.org/docs/releases.html).
• Google March 2026 broad core update — Search Status Dashboard and reporting (rolled out over ~12 days; check timeline before analysing traffic).

Next edits

• Add a small checklist and sample llms-full.txt generator script for common CMSs (Next.js, WordPress) — included here (Node script example).
• Add a short Web Guide optimization tactic with before/after examples for H2 clustering — included in Step 6
• Add automated tests: JSON-LD validation against schema.org, llms.txt format check, and nightly Search Console sanity checks

Experiments and monitoring

• Nightly JSON-LD validation run against the official schema.org release and flag new or deprecated terms
• Weekly llms.txt integrity check against public/llms.txt and a sampling of llms-full.txt snapshots
• A/B test: split long-form pages into H2-clustered sections (with one-sentence leads) vs. monolithic article to measure citation and click differences in AI-organized SERPs

Contact

For detailed implementation help, include SERP samples, top 10 competitor URLs, and a sitemap so we can produce a focused entity-gap plan.