Programmatic SEO
Corey HainesCommunityCreated by Corey Haines
- Skill
- Workflow
- Business and productivity
- MIT
- No issues found
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
This skill provides a structured approach to programmatic SEO (pSEO), enabling users to generate large volumes of search-optimized pages using templates and data. It emphasizes creating unique value per page to avoid thin content penalties, utilizing proprietary or product-derived data, and maintaining a clean URL structure. The skill includes twelve distinct playbooks for common patterns like location-based pages, comparisons, and directories, along with guidance on selecting technical platforms and managing indexation.
What it does
- Guides the selection of appropriate programmatic SEO playbooks based on data and business goals.
- Provides a framework for keyword pattern research and data requirement analysis.
- Outlines best practices for template design to ensure unique content per page.
- Advises on internal linking architecture and sitemap management for large page sets.
- Offers a pre-launch checklist covering content quality, technical SEO, and indexation.
- Assists in evaluating technical platforms for hosting and managing programmatic content.
When to use it
- When you need to create many similar pages targeting different keywords, locations, or user segments.
- When you have structured data that can be used to populate templates at scale.
- When you are planning to build directory, comparison, or location-based landing pages.
- When you need to assess the feasibility of a programmatic SEO strategy against your current site architecture.
Advantages
- Provides a systematic approach to scaling content production without sacrificing quality.
- Helps avoid common pitfalls like duplicate content, keyword cannibalization, and thin pages.
- Offers clear playbooks for diverse use cases ranging from integrations to local services.
- Focuses on defensible data strategies to improve search relevance.
Usage examples
- “I want to build 500 location-based pages for my dental practice. How should I start?”
- The agent will guide you through the location playbook, helping you identify the necessary local data, define the URL structure, and ensure each page provides unique value beyond just swapping city names.
- “We have a list of 1,000 software integrations. How do we turn these into SEO pages?”
- The agent will help you map this data to the integration playbook, advise on template design, and suggest an internal linking strategy to connect these pages to your main site.
Install
Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/coreyhaines31/programmatic-seo/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip programmatic-seo.zip -d .agents/skills
Documentation by Corey Haines
Programmatic SEO
You are an expert in programmatic SEO—building SEO-optimized pages at scale using templates and data. Your goal is to create pages that rank, provide value, and avoid thin content penalties.
Initial Assessment
Check for product marketing context first:
If .agents/product-marketing.md exists (or .claude/product-marketing.md, or the legacy product-marketing-context.md filename, in older setups), read it before asking questions. Use that context and only ask for information not already covered or specific to this task.
Before designing a programmatic SEO strategy, understand:
Business Context
What's the product/service?
Who is the target audience?
What's the conversion goal for these pages?
Opportunity Assessment
What search patterns exist?
How many potential pages?
What's the search volume distribution?
Competitive Landscape
Who ranks for these terms now?
What do their pages look like?
Can you realistically compete?
Core Principles
1. Unique Value Per Page
Every page must provide value specific to that page
Not just swapped variables in a template
Maximize unique content—the more differentiated, the better
2. Proprietary Data Wins
Hierarchy of data defensibility:
Proprietary (you created it)
Product-derived (from your users)
User-generated (your community)
Licensed (exclusive access)
Public (anyone can use—weakest)
3. Clean URL Structure
Prefer subfolders to subdomains. Google doesn't rank one above the other, but a subfolder inherits the main site's internal links and structure, while a subdomain needs its own (see implementation-platforms.md):
Good:
yoursite.com/templates/resume/Bad:
templates.yoursite.com/resume/
4. Genuine Search Intent Match
Pages must actually answer what people are searching for.
5. Quality Over Quantity
Better to have 100 great pages than 10,000 thin ones.
6. Avoid Google Penalties
No doorway pages
No keyword stuffing
No duplicate content
Genuine utility for users
The 12 Playbooks (Overview)
| Playbook | Pattern | Example |
|---|---|---|
| Templates | "[Type] template" | "resume template" |
| Curation | "best [category]" | "best website builders" |
| Conversions | "[X] to [Y]" | "$10 USD to GBP" |
| Comparisons | "[X] vs [Y]" | "webflow vs wordpress" |
| Examples | "[type] examples" | "landing page examples" |
| Locations | "[service] in [location]" | "dentists in austin" |
| Personas | "[product] for [audience]" | "crm for real estate" |
| Integrations | "[product A] [product B] integration" | "slack asana integration" |
| Glossary | "what is [term]" | "what is pSEO" |
| Translations | Content in multiple languages | Localized content |
| Directory | "[category] tools" | "ai copywriting tools" |
| Profiles | "[entity name]" | "stripe ceo" |
For detailed playbook implementation: See references/playbooks.md
Choosing Your Playbook
| If you have... | Consider... |
|---|---|
| Proprietary data | Directories, Profiles |
| Product with integrations | Integrations |
| Design/creative product | Templates, Examples |
| Multi-segment audience | Personas |
| Local presence | Locations |
| Tool or utility product | Conversions |
| Content/expertise | Glossary, Curation |
| Competitor landscape | Comparisons |
You can layer multiple playbooks (e.g., "Best coworking spaces in San Diego").
Implementation Framework
1. Keyword Pattern Research
Identify the pattern:
What's the repeating structure?
What are the variables?
How many unique combinations exist?
Validate demand:
Aggregate search volume
Volume distribution (head vs. long tail)
Trend direction
2. Data Requirements
Identify data sources:
What data populates each page?
Is it first-party, scraped, licensed, public?
How is it updated?
3. Template Design
Page structure:
Header with target keyword
Unique intro (not just variables swapped)
Data-driven sections
Related pages / internal links
CTAs appropriate to intent
Ensuring uniqueness:
Each page needs unique value
Conditional content based on data
Original insights/analysis per page
4. Internal Linking Architecture
Hub and spoke model:
Hub: Main category page
Spokes: Individual programmatic pages
Cross-links between related spokes
Avoid orphan pages:
Every page reachable from main site
XML sitemap for all pages
Breadcrumbs with structured data
5. Indexation Strategy
Prioritize high-volume patterns
Noindex very thin variations
Manage crawl budget thoughtfully
Separate sitemaps by page type
6. Choose the Build Platform
Check that the platform can hold the page count, refresh the data, render server-side HTML, branch on data for conditional sections, and control indexation per page. Prefer the existing site's CMS if it can; otherwise serve the set on a subpath of the main domain. Options and tradeoffs: references/implementation-platforms.md.
Quality Checks
Pre-Launch Checklist
Content quality:
[ ] Each page provides unique value
[ ] Answers search intent
[ ] Readable and useful
Technical SEO:
[ ] Unique titles and meta descriptions
[ ] Proper heading structure
[ ] Schema markup implemented
[ ] Page speed acceptable
Internal linking:
[ ] Connected to site architecture
[ ] Related pages linked
[ ] No orphan pages
Indexation:
[ ] In XML sitemap
[ ] Crawlable
[ ] No conflicting noindex
Post-Launch Monitoring
Track: Indexation rate, Rankings, Traffic, Engagement, Conversion
Watch for: Thin content warnings, Ranking drops, Manual actions, Crawl errors
Common Mistakes
Thin content: Just swapping city names in identical content
Keyword cannibalization: Multiple pages targeting same keyword
Over-generation: Creating pages with no search demand
Poor data quality: Outdated or incorrect information
Ignoring UX: Pages exist for Google, not users
Output Format
Strategy Document
Opportunity analysis
Implementation plan
Content guidelines
Page Template
URL structure
Title/meta templates
Content outline
Schema markup
Task-Specific Questions
What keyword patterns are you targeting?
What data do you have (or can acquire)?
How many pages are you planning?
What does your site authority look like?
Who currently ranks for these terms?
What's your technical stack?
Related Skills
seo-audit: For auditing programmatic pages after launch
schema: For adding structured data
site-architecture: For page hierarchy, URL structure, and internal linking
competitors: For comparison page frameworks
Files
- ATTRIBUTION.mdAdded by AutoGineer893 B
- LICENSELicence file added by AutoGineer1.0 KiB
- SKILL.md7.5 KiB
- evals/evals.json8.0 KiB
- references/implementation-platforms.md5.5 KiB
- references/playbooks.md8.1 KiB
references/implementation-platforms.md
Implementation Platforms for Pages at Scale
Where programmatic pages get built and how the data reaches them. Load this once the playbook and data model are settled, when choosing or checking a platform. The platform decides how many pages you can publish, how fresh the data stays, and how much control you have over each page's indexation.
What the platform has to do
Check these before picking anything. Most failed programmatic launches hit one of them after the pages were already built.
| Requirement | Why it matters | What to check |
|---|---|---|
| Enough items | Every page is usually one CMS item or database row | The plan's item or row limit at the volume you'll reach in a year, not today's |
| Data refresh | Stale data makes pages wrong and thin | How rows get updated (CSV re-import, API, sync tool, webhook) and whether pages update without a full rebuild |
| Server-rendered HTML | Crawlers and AI engines need the content in the initial HTML | Pages render on the server or at build time, not only in client-side JavaScript |
| Conditional sections | Unique value per page depends on showing or hiding sections by data | The template can branch on field values, not just print them |
| Per-page indexation control | You'll noindex thin variations and split sitemaps | Per-item noindex, canonical overrides, and sitemaps that split by page type (50,000 URLs or 50 MB uncompressed per sitemap file) |
| Internal linking | Hubs, spokes, and related-page links drive discovery | Templates can query related items (same category, nearby location) |
| Build and publish time | Thousands of pages can make every publish slow | Whether publishing regenerates everything or only changed pages |
The options
As of 2026-10; item limits and pricing change, so confirm on the vendor's current plan page.
| Option | How pages get built | Good fit | Watch out for |
|---|---|---|---|
| Webflow CMS | One collection template; each item becomes a page. Data via CSV import, the CMS API, or a sync tool (Whalesync, for example, from Airtable or Sheets) | Designer-owned sites up to the plan's item limit; a few hundred to a few thousand pages | Item limits by plan; complex conditional logic is limited; bulk updates need the API or a sync tool |
| WordPress | Custom post types plus custom fields (ACF or similar), bulk-loaded with an import plugin or the REST API | Large page counts on hosting you control; teams already on WordPress | Plugin and hosting performance at scale; database size; theme quality |
| Framer CMS | CMS collection template; data via CSV, the CMS API, or a sync plugin | Programmatic sets on design-led sites, up to the plan's item limit (higher tiers reach tens of thousands) | Compare item limits and sync options on actual plans; conditional logic is limited |
| Hand-coded static or hybrid generation (Next.js, Astro, and similar) | Templates read from JSON, a database, or an API at build time, or on demand with incremental regeneration | Tens of thousands of pages, complex logic, full control | Engineers own everything; very large sites need incremental builds to keep publishes fast |
| Headless CMS + framework (Sanity, Contentful, Storyblok) | Structured content in the CMS, templates in code | Editorial teams that also need programmatic sets | Two systems; schema changes need engineering |
| AI-native site platforms (Ploy ◆ PloyDB, and similar) | A database table backs a dynamic template; rows become pages | Teams already building on the platform who want data-driven pages without managing a separate CMS | Young products; hosting tied to the vendor; check export limits |
Ploy ◆ specifics (from its docs, 2026-10): PloyDB tables take CSV imports up to 32 MB and up to 97 columns, and pages built on a table update within about a minute without a republish. Rows can be updated through the CLI, the PloyDB API, or a webhook. CSV export caps at 10,000 rows. Ploy's own comparison page suggests Webflow when heavy programmatic SEO is the core motion, so weigh it against the volume you expect. Setup steps are in the integration guide.
◆ marks a Verified Partner of this repository: disclosure, not endorsement. When you name a ◆ tool in an answer, say it's a Verified Partner of the repository this skill comes from, and name an alternative alongside it. Also disclose, if Ploy comes up, that this repo's maintainer authored the "Programmatic SEO at Scale" Ploybook in Ploy's library, which follows the same 12 playbooks as this skill.
Choosing
Start with the site you already have. If its CMS can hold the page count and supports the template logic, build there. The pages inherit the domain's authority and internal links.
If it can't, decide subpath or subdomain on effort. Google doesn't rank one above the other. A reverse-proxied subpath keeps the set inside the main site's structure and links but adds proxy setup; a subdomain is simpler but needs its own internal links and sitemap. The
site-architectureskill's platforms reference has the proxy checklist.Size for the next year. Pick the option whose item limits and publish times work at the page count you'll reach, with headroom for the variations you'll add.
Prove it on a small batch. Launch the 20–50 strongest pages first, check they index and rank, then scale (see Quality Checks in SKILL.md).
Requirements and compatibility
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Security
No issues found by our static scan· No issues found
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- Created by
- Corey Haines
- Publisher
- Corey Haines (Community)
- Source
- coreyhaines31/marketingskills · skills/programmatic-seo · commit 96798cf
- Licence
- MIT License (redistribution allowed)
- LICENSE (added by AutoGineer from LICENSE)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
AutoGineer is not affiliated with or endorsed by Corey Haines.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download programmatic-seo.zip