Programmatic SEO 2.0 — Agent Skill Reference

---

name: pseo-generator

description: "Build Programmatic SEO 2.0 systems at scale — AI-generated content using strict JSON schemas, niche taxonomy, and React renderers. Use when: (1) creating hundreds or thousands of programmatic pages, (2) building a niche taxonomy for pSEO content, (3) designing JSON schemas for AI-generated content types, (4) separating content generation from UI presentation, (5) generating resource pages, comparison pages, free tools, or checklist pages at scale. NOT for: traditional one-off page writing, keyword research only, or thin AI content that ignores niche context."

---

# Programmatic SEO 2.0 — Agent Skill Reference

The core principle: **never ask AI to write freeform content. Ask it to fill a strict JSON schema.**

Content = JSON data. Design = React components. These two layers never mix.

System Architecture

Niche Taxonomy (309 niches) → AI fills JSON schema → Validated JSON files → React renderers → Published pages

**Why schemas beat freeform:**

Step 1: Build the Niche Taxonomy

This is the most important investment. Rich niche context is what separates useful pSEO from thin name-swapped filler.

For each niche, define:

{
  "slug": "travel",
  "name": "Travel",
  "context": {
    "audience": "Armchair travelers, digital nomads, family vacation planners",
    "pain_points": "Seasonal traffic swings, high competition for destination keywords",
    "monetization": "Affiliate (booking, gear), display ads, sponsored trips",
    "content_that_works": "Itineraries, cost breakdowns, off-the-beaten-path guides",
    "subtopics": ["budget travel", "luxury travel", "adventure travel", "solo travel"]
  }
}

Start with 20-50 niches, expand to 300+ for scale. This context gets injected into every generation prompt — it's what makes a "travel SEO checklist" different from a "health SEO checklist."

See `references/niche-taxonomy.md` for the full niche structure and 20 starter niches.

Step 2: Design JSON Schemas per Content Type

Each content type gets its own schema. Constraints are intentional — they force consistent output.

**Example: Resource Article Schema**

interface ResourceArticle {
  meta: {
    content_type: string;
    niche: string;
  };
  seo: {
    title: string;        // templated, NOT AI-generated
    description: string;
    keywords: string[];
  };
  content: {
    intro: string;
    sections: {
      heading: string;
      items: {
        title: string;
        description: string;
        difficulty?: 'beginner' | 'intermediate' | 'advanced';
        potential?: 'high' | 'medium' | 'standard';
      }[];  // exactly 15-20 per section
    }[];
    pro_tips: string[];  // exactly 5
  };
}

Hard constraints (exact counts, required fields) prevent 8-item pages next to 40-item pages. See `references/schema-library.md` for 6 ready-to-use schemas.

Step 3: The 6 Content Categories

| Category | Share | Notes |

|---|---|---|

| Resource pages | ~58% | Idea lists, checklists, calendars, guides, templates — 34 content types × N niches |

| Comparison pages | ~1% | Smallest category — most obvious, least differentiated |

| Free tools | ~15% | Actual working tools with niche-specific examples |

| Checklist pages | ~10% | Interactive, niche-aware |

| Guide pages | ~8% | Long-form, structured |

| Template pages | ~8% | Downloadable/fillable |

Resource pages are the highest-volume opportunity. Start there.

Step 4: Generation at Scale

Use Gemini Flash (cost-to-quality ratio beats GPT-4 for structured JSON at volume).

**Why Gemini Flash:**

**Generation prompt pattern:**

Given this niche context: {niche_json}
Fill this schema: {schema}
Content type: {content_type}
Title template: {title}

Return ONLY valid JSON matching the schema. No prose, no markdown.

**Validation:** After generation, validate every file against the TypeScript schema. Reject and retry any that fail. At 13,000 pages, ~2-5% failure rate is normal.

**Speed:** 13,000+ pages in under 3 hours with parallel workers (10-20 concurrent API calls).

Step 5: React Renderers

Each content type gets its own specialized renderer. The renderer consumes the JSON and handles all presentation.

/renderers/
  ResourceArticleRenderer.tsx   — with filtering by category/difficulty
  ChecklistRenderer.tsx          — interactive checkboxes
  ComparisonTableRenderer.tsx    — structured tables
  FreeToolRenderer.tsx           — working tool UI

**Key rule:** Renderers never call AI. They only consume pre-generated JSON. This means you can:

Key Metrics (Jake Ward experiment, 60 days)

Quick Start Checklist

References

---

Tolstoy-Specific Configuration

When generating pSEO content for **gotolstoy.com**, always load these files before generating any content:

Tolstoy Voice Rules (non-negotiable)

1. **Positioning:** Always use "AI Agent for Ecommerce" — never "tool" or "software"

2. **Products:** Name specifically: AI Studio, AI Player, AI Shopper

3. **Vocabulary:** "at scale," "autonomous," "closed loop," "without manual work"

4. **Tone:** Second-person ("you"), data-forward, peer-to-peer operator voice

5. **Proof metrics:** 7x PDP conversion lift, 232% AOV uplift, 11x conversion rate with AI Shopper, 2,000+ brand partners

6. **Do NOT:** Name competitors directly in body copy — stay category-level

7. **Closed loop framing:** AI Studio creates → AI Player distributes → AI Shopper converts → data loops back

Tolstoy Content Map (20 pages total)

| Type | Count | Status |

|---|---|---|

| Comparison pages (Tolstoy vs X) | 8 | 1 done (Rep AI) |

| Topic/gap pages (category attack) | 7 | 0 done |

| Use case pages | 4 | 0 done |

**Highest priority gaps** (Tolstoy absent from AI Overviews):

Webflow Publishing (when API key is available)

Tolstoy blog runs on Webflow CMS. Publishing flow:

1. Generate content JSON against schema

2. Render to HTML/markdown via renderer

3. POST to Webflow CMS API: `POST /v2/collections/{collection_id}/items`

4. Publish item: `POST /v2/collections/{collection_id}/items/{item_id}/publish`

Required fields for Webflow blog item (to be confirmed with API key):