🚀 Skill: programmatic-seo-pro (v1.0.0)

Executive Summary

Senior Programmatic SEO Architect & Data Engineer for 2026. Specialized in large-scale page generation using Next.js 16, dynamic metadata orchestration, and database-to-page automation. Expert in scaling content across thousands of long-tail segments while maintaining high E-E-A-T standards and optimizing for AI-driven Search Generative Experiences (SGE).

---

📋 The Conductor's Protocol

1. Dataset Analysis: Evaluate the source data (CSV, DB, headless CMS) for quality, structure, and semantic richness.
2. Keyword Clustering: Identify high-intent, low-competition long-tail segments for programmatic expansion.
3. Sequential Activation: activate_skill(name="programmatic-seo-pro") → activate_skill(name="next16-expert") → activate_skill(name="seo-pro").
4. Verification: Execute a small batch generation (10-50 pages) and audit for content uniqueness, metadata accuracy, and Core Web Vitals.

---

🛠️ Mandatory Protocols (2026 Standards)

1. Dynamic Metadata Mastery

As of 2026, static metadata is for amateurs. Every programmatic page must have a unique, data-driven identity.

• Rule: Use Next.js 16 generateMetadata for every dynamic route.
• Protocol: Inject specific data points (prices, counts, locations) directly into titles and descriptions to increase CTR.

2. Authority-First Scaling (E-E-A-T)

• Rule: Avoid "thin" programmatic pages. Every page must provide unique value, not just a template swap.
• Protocol: Use AI to augment templates with proprietary data, expert insights, and localized context.

3. Structured Data as a Requirement

• Rule: Every programmatic page MUST include JSON-LD (Schema.org) to be eligible for SGE summaries.
• Protocol: Automatically generate FAQPage, Product, or LocalBusiness schema based on the underlying dataset.

4. Incremental & Edge Caching

• Rule: Never rebuild the entire site for a data update. Use Next.js 16's refined caching and ISR.
• Protocol: Set appropriate revalidate intervals and use revalidateTag for real-time data sync from the headless CMS.

---

🚀 Show, Don't Just Tell (Implementation Patterns)

Dynamic Routing & Metadata (Next.js 16)

apps/web/src/app/cities/[slug]/page.tsx:

import { Metadata } from 'next';

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

export async function generateMetadata({ params }: Props): Promise<Metadata> {
  const { slug } = await params;
  const data = await getCityData(slug);
  
  return {
    title: `Best Coworking Spaces in ${data.name} (2026 Guide)`,
    description: `Discover ${data.count} top-rated spaces in ${data.name}. Average price: ${data.avgPrice}. Verified by local experts.`,
    alternates: { canonical: `https://example.com/cities/${slug}` }
  };
}

export default async function Page({ params }: Props) {
  const { slug } = await params;
  // Render high-value, data-driven content here
}

Structured Data Injection

const jsonLd = {
  '@context': 'https://schema.org',
  '@type': 'FAQPage',
  'mainEntity': data.faqs.map(faq => ({
    '@type': 'Question',
    'name': faq.question,
    'acceptedAnswer': { '@type': 'Answer', 'text': faq.answer }
  }))
};

return (
  <script
    type="application/ld+json"
    dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
  />
);

---

🛡️ The Do Not List (Anti-Patterns)

1. DO NOT create "doorway pages" that only exist to link elsewhere. Every page must be a destination.
2. DO NOT generate content that is 90% identical across pages. AI will flag it as "Low Quality."
3. DO NOT ignore the crawl budget. Use robots.txt to block low-value parameter variations.
4. DO NOT hardcode data. Use a headless CMS or a robust database (Postgres/Convex) as the source of truth.
5. DO NOT forget internal linking. Programmatic pages must be part of a logical site hierarchy (Topic Clusters).

---

📂 Progressive Disclosure (Deep Dives)

• Data-to-Page Automation (./references/data-automation.md): Strategies for CSV/JSON/SQL ingestion.
• Next.js 16 SEO Features (./references/nextjs-seo-deep-dive.md): Metadata API, Streaming, and Caching.
• SGE Optimization for Scale (./references/sge-scaling.md): Designing for AI summaries at scale.
• Modular Content Blocks (./references/modular-blocks.md): Building unique pages from reusable components.

---

🛠️ Specialized Tools & Scripts

• scripts/generate-sitemap-index.ts: Paginates sitemaps for sites with 50,000+ pages.
• scripts/audit-duplicate-content.py: Uses NLP to identify pages that are too similar.

---

🎓 Learning Resources

• Programmatic SEO Guide (https://example.com/p-seo-guide)
• Next.js App Router Metadata Docs (https://nextjs.org/docs/app/building-your-application/optimizing/metadata)
• E-E-A-T for Scaling Content (https://example.com/eeat-scaling)

---

Updated: January 23, 2026 - 20:35

---

Supporting file: references/data-automation.md

Data-to-Page Automation Strategies

The Data Pipeline

Scaling to thousands of pages requires a robust pipeline that transforms raw data into structured web content.

---

1. Source Selection

• Headless CMS (Contentful/Sanity/Strapi): Best for content-rich pages where non-technical editors need to update text/images.
• Relational DB (Postgres/MySQL): Best for data-heavy sites (e.g., job boards, real estate listings, directory sites).
• Static JSON/CSV: Best for smaller-scale programmatic projects or datasets that rarely change.

---

2. The Ingestion Logic

Use a "Pre-processor" to clean and enrich data before it reaches the frontend.

• Deduplication: Ensure no two data points will generate the exact same page title or slug.
• Sentiment Analysis: Use AI to ensure user-generated content in the dataset is safe and high-quality.
• Semantic Tagging: Automatically tag data points with relevant categories for internal linking.

---

3. Dynamic Template Injection

Instead of static text, use variables that pull directly from the dataset.

• Bad: "This is a great city to live in."
• Elite: "With a cost of living ${data.costRank}% lower than the national average, ${data.cityName} is a top choice for ${data.persona}s."

---

4. Automatic Internal Linking

Don't rely on a manual sidebar. Build a "Related Entities" engine.

• If a user is on a page for "React Jobs in London", the engine should automatically link to "TypeScript Jobs in London" and "React Jobs in Manchester".

---

Supporting file: references/modular-blocks.md

Modular Content Blocks for Programmatic SEO

Avoiding "Template Fatigue"

Users (and AI) can spot a generic template from a mile away. Use modular blocks to create variety.

---

1. Component Libraries

Build a library of 10-20 reusable UI blocks:

• HeroSection
• ComparisonTable
• TestimonialCarousel
• FaqAccordion
• ExpertInsightBox
• DataVisualizer (Charts/Graphs)

---

2. Randomization with Purpose

Don't use every block on every page. Use a logic engine to decide which blocks to show.

• Rule: If data.hasReviews, show TestimonialCarousel. If data.hasPricing, show PricingTable.
• Variety: Randomize the order of certain non-critical blocks to prevent search engines from seeing them as duplicate page structures.

---

3. AI-Augmented Blocks

Use LLMs to write a 100-word "Introduction" for each page that uses the raw data to create a natural, human-sounding narrative. This increases the "Uniqueness" score of the page.

---

4. Layout-as-Data

Store your page layouts in the CMS.

• Example: A "Destination" page layout might consist of [Hero, Map, TopSights, Weather, Faq].
• This allows you to change the structure of 10,000 pages by simply editing a single layout object in your CMS.

---

Supporting file: references/nextjs-seo-deep-dive.md

Next.js 16 SEO Features Deep Dive

The Metadata API

Next.js 16 simplifies SEO by centralizing metadata management in layout.tsx and page.tsx.

1. Static Metadata

export const metadata: Metadata = {
  title: 'My Programmatic Site',
  description: 'Scalable content for the AI era.',
};

2. Dynamic Metadata

export async function generateMetadata({ params }): Promise<Metadata> {
  const data = await fetchData(params.slug);
  return {
    title: `${data.name} | My Site`,
    openGraph: { images: [data.imageUrl] },
  };
}

---

Streaming & Perceived Performance

Next.js 16 streams the <head> separately from the <body>.

• Benefit: Search engines get the meta tags instantly, even if the body content takes time to fetch from a slow DB or API.
• Bot Behavior: Bots like Googlebot wait for the metadata to resolve before indexing the page.

---

Caching & Revalidation

ISR (Incremental Static Regeneration)

Use revalidate at the page level or next: { revalidate: 3600 } in fetch.

Tag-Based Revalidation

Use revalidateTag('my-data-tag') to purge the cache only when the underlying data in your CMS or DB changes. This is the "Elite" way to handle programmatic scale without wasting server resources.

---

Image & Font Optimization

• next/image: Automatically serves WebP/AVIF and handles lazy loading. Essential for Core Web Vitals (LCP).
• next/font: Zero layout shift (CLS) by pre-loading and optimizing fonts locally.

---

Supporting file: references/sge-scaling.md

SGE Optimization for Scale (2026)

What is SGE?

Search Generative Experience (SGE) is Google's AI-powered overview that appears at the top of search results. To be included, your programmatic content must be "SGE-Ready."

---

1. The "Answer-First" Pattern

SGE favors direct answers to user questions.

• Protocol: Start your programmatic pages with a "TL;DR" or a direct answer to the primary long-tail query.
• Example: If the query is "Is it safe to live in ${city}?", the first paragraph should be: "Yes, ${city} has a safety rating of ${data.safetyScore}, which is ${data.comparison}% better than average."

---

2. Semantic Richness over Keyword Density

AI models understand concepts, not just words.

• Protocol: Use a variety of related entities and synonyms. If you're building pages for "Running Shoes," mention "Marathons," "Foot Health," "Treadmills," and "Durability."

---

3. Tables & Structured Insights

AI loves data it can easily parse.

• Protocol: Every programmatic page should have at least one comparison table or a list of "Key Specifications."

---

4. Authoritative Citations

E-E-A-T is more important than ever.

• Protocol: Link to official sources (gov sites, industry reports, verified reviews) to back up your data-driven claims. AI is more likely to cite your page if you cite your sources.

---

5. Schema.org (JSON-LD)

Schema is the "API" for Search Engines.

• Protocol: Be aggressive with schema. Use Product, Review, FAQPage, HowTo, and Dataset schemas on every single programmatic page.
  • Check with bun x redocly lint or official Google Search Console tools.