My 10-Day Programmatic SEO System - Prompts Inside

LLM prompt templates for programmatic SEO

When you need consistent, fast output, this set brings order to the chaos. Use them to publish at scale while keeping control of facts, internal links, and structured data. Programmatic SEO with LLMs can look complex, but it feels lighter once a few guardrails are in place. For more reusable patterns, explore this Prompt Library.

Quick how-to sequence

• Define the base entity: product, service, solution, or topic.
• List attributes: features, use cases, industries, pricing, geo, proof sources.
• Pick a data source: CSV, Google Sheets, or a database table.
• Set guardrails: factual sources, dedupe rules, tone, brand words to avoid.
• Success metrics: indexation rate, CTR, qualified leads, assisted conversions.

10-day pilot plan

• Day 1: Choose one entity set and a narrow stack of 100 keywords. Confirm intent types.
• Day 2: Draft the global system prompt and one page template. Add tone, facts policy, and internal linking rules.
• Day 3: Dry run on 10 rows. Review slugs, titles, meta, and outlines.
• Day 4: Add structured data generation and validation. Fix field mapping.
• Day 5: Add embedding-based dedupe and canonical suggestion logic.
• Day 6: Wire a small pipeline: Sheets → function → LLM API → validation → CMS draft.
• Day 7: Human spot-check 20 pages. Mark issues and refine prompts.
• Day 8: Push 50 pages to staging with noindex. Recheck titles, H1, links, schema.
• Day 9: Publish the clean half. Submit sitemap and request indexing.
• Day 10: Review early crawl stats and first clicks. Tune internal links and titles.

Global system prompt skeleton

You are a senior SEO editor for a B2B services brand. Follow these rules:
- Match search intent succinctly: transactional, commercial, or informational.
- Keep titles ≤60 chars, meta descriptions ≤155 chars.
- Cite facts from the provided {PrimarySourceURL} or return "needs source".
- Reject duplicate topics if semantic similarity >0.92 vs provided corpus.
- Format outputs exactly as requested without extra commentary.
- Tone: clear, direct, helpful. No hype.
- Avoid: "leverage", "best practices", "ultimate", jargon with no value.

Automated keyword-to-page pipelines with LLM

When you want a single CSV row to become a publish-ready page package, this template handles slugs, titles, on-page copy, internal links, FAQs, and JSON-LD. It also suggests canonicals if it finds overlap.

Prompt template

Task: Turn a single CSV row into a ready-to-publish page bundle.

Inputs:
- {Keyword}
- {EntityType}
- {SearchIntent}  // transactional, commercial, informational
- {Geo}           // optional city/region
- {Audience}      // e.g., IT directors at mid-market firms
- {CTA}           // e.g., "Book a demo"
- {PrimarySourceURL} // factual source

Resources:
- sitemap_urls: [paste a plain list of internal URLs with titles]
- embeddings_reference: [short list of reference titles + vector IDs]
- similarity_threshold: 0.92

Output format:
1) slug: lowercase, hyphenated, ≤60 chars
2) h1
3) title_tag: ≤60 chars
4) meta_description: ≤155 chars
5) outline: H2/H3 only
6) body: 800–1,000 words, short paragraphs, concrete examples, no fluff
7) internal_links: 5–8 relevant links, each with anchor + URL from sitemap
8) faqs: 3–5 Q&A that match intent
9) schema_jsonld: valid JSON-LD for WebPage + FAQPage
10) canonical_suggestion: "self" or URL of near-duplicate
11) source_notes: list claims that need source if any

Rules:
- Check semantic similarity vs embeddings_reference. If >0.92 with any, set canonical_suggestion to the closest match and avoid repeating the same angle.
- All facts must be cited from {PrimarySourceURL}. If unknown, tag the sentence with [needs source].
- Keep keyword usage natural. Avoid stuffing.
- Prefer internal anchors that reflect the target page’s title or H1.

Now process this row and return only the requested fields.

Integration sketch

• Google Sheets: source table with columns matching the inputs.
• Cloud Function or serverless job: calls your LLM API and the embedding service.
• Validation script: checks title length, meta length, JSON-LD validity, link targets.
• CMS import: write to staging, add noindex until QA passes.

The competitor gap to close here: internal linking and canonical logic are first-class citizens, not an afterthought.

Scalable long-tail SEO using LLM templates

Long-tail doesn't mean thin. This slot format builds intent-first pages like {Service} in {City} for {Industry}, while forcing real, page-specific proof. Yes, scalable can worry people because it suggests sameness. The fix is simple: require unique facts and enforce them.

Slot template with RAG and uniqueness rules

Goal: Create a location-industry service page that avoids doorway patterns.

Inputs:
- {Service}
- {City}
- {Industry}
- {Audience}
- {PrimarySourceURL}
- rag_index: endpoint to query local stats, regulations, case snippets, testimonials

Requirements:
- Uniqueness quota: ≥30% of the body must be page-specific facts:
  - at least 1 local stat with source
  - 1 case snippet or mini testimonial relevant to {City} or {Industry}
  - 1 regulation, standard, or compliance note if applicable
- Variation budget:
  - Rotate intros (min 5 variants)
  - Rotate proof blocks (min 5 formats: stat, quote, mini case, checklist, comparison)
  - Rotate CTA phrasing (min 3 variants)

Process:
1) Query rag_index for {Service}, {City}, {Industry}. Return top verified passages with citations.
2) Draft outline with H2/H3 that reflect local needs.
3) Write 900–1,100 words with clear sections:
   - Intro (rotated)
   - Why {Service} for {Industry} in {City}
   - Local proof block (rotated format)
   - Process summary
   - Pricing or scoping guidance
   - CTA block (rotated)
4) Insert citations next to each local fact. If a fact cannot be verified, tag [needs source].
5) Run similarity check vs other {City} or {Industry} pages. If similarity >0.92, rewrite proof and intro.

Return:
- h1, title, meta, outline, body, internal_links, schema_jsonld, proof_mix_used, uniqueness_score.

In practice, programmatic SEO with LLMs shines when uniqueness is enforced at the template level, not as a manual fix later.

Programmatic landing page generation with GPT

Content is only half the job. The page must convert. This JSON output feeds modular CMS blocks and supports A/B testing without redesign. You can draft this in ChatGPT and swap in your CMS keys.

Prompt for modular JSON

Task: Produce a conversion-ready landing page as JSON for a modular CMS.

Inputs:
- {Audience}
- {Problem}
- {ServiceOrProduct}
- {PrimaryBenefit}
- {SecondaryBenefit}
- {ProofAssets} // case stats, logos, quotes
- {CTA}         // single, consistent action
- {ComplianceNotes} // optional

Output JSON keys:
{
  "hero": {
    "h1_variant_a": "",
    "h1_variant_b": "",
    "subhead": "",
    "primary_cta": "{CTA}",
    "above_the_fold_checklist": [
      "Clear outcome in first line",
      "Single CTA visible",
      "No jargon in hero"
    ]
  },
  "pain_solution": {
    "problem": "",
    "solution": "",
    "before_after_bullets": ["", "", ""]
  },
  "benefits": [
    {"title": "", "blurb": ""},
    {"title": "", "blurb": ""},
    {"title": "", "blurb": ""}
  ],
  "proof": {
    "logos": ["", ""],
    "case_stats": [{"metric": "", "value": "", "source": ""}],
    "testimonial": {"quote": "", "attribution": ""}
  },
  "packages": [
    {"name": "", "summary": "", "ideal_for": "", "starting_price_note": ""}
  ],
  "faqs": [{"q": "", "a": ""}, {"q": "", "a": ""}],
  "trust": {"badges": ["", ""], "compliance": "{ComplianceNotes}"},
  "final_cta": {"headline": "", "cta_copy_variant_a": "", "cta_copy_variant_b": ""},
  "ab_test_fields": ["hero.h1_variant_a", "hero.h1_variant_b", "final_cta.cta_copy_variant_a", "final_cta.cta_copy_variant_b"],
  "conversion_guardrails": [
    "One primary CTA across the page",
    "Answer top objections in FAQs",
    "Avoid weak verbs; show outcomes"
  ],
  "ppc_alignment_optional": {
    "headline_for_adgroup": "",
    "description_line": "",
    "keyword_insertions": ["", ""]
  }
}
Rules:
- Plain language. Short sentences. No fluff.
- Keep hero promise specific to {Audience} and {Problem}.
- All numbers in proof must have a source or be marked [needs source].
Return only JSON.

Structured data templates with LLM for SEO

Schema isn't glamorous, but it compounds benefits. Use these structured data templates with LLMs to stamp out consistent JSON-LD, validate it, and keep version control.

Prompt to generate and validate JSON-LD

Task: Output valid JSON-LD for the given page type and validate it.

Inputs:
- page_type: Service | LocalBusiness | FAQPage | BreadcrumbList | Review
- fields: {
    "BusinessName": "",
    "Address": {"streetAddress":"", "addressLocality":"", "addressRegion":"", "postalCode":"", "addressCountry":""},
    "ServiceArea": ["", ""],
    "PriceRange": "",
    "AggregateRating": {"ratingValue":"", "reviewCount":""},
    "Breadcrumbs": [{"name":"", "item":""}],
    "FAQs": [{"q":"", "a":""}],
    "SpeakableSelectors": ["#hero h1", ".summary p"]
  }
- version_key: "schema_v1.2.0"

Output:
1) schema_jsonld: JSON only, no comments
2) validator_instructions:
   - Test using Google's Rich Results Test and Schema.org validator.
   - If errors appear, list them under "errors" and self-correct.
3) version_key: echo the provided version_key

Rules:
- Include @context and @type correctly.
- For LocalBusiness, include openingHoursSpecification if hours are known.
- Add "speakable" where applicable to support voice.
- Use FAQPage only if FAQs exist on the page.
- Keep fields consistent with the provided inputs.
Return the three items in a single JSON object.

Add an auto-validation step that calls a markup testing API or headless run, then log warnings with the version_key so changes are trackable over time.

Entity-based programmatic SEO templates

When a catalog spans products, services, integrations, and industries, entity-first planning reduces confusion and improves internal links. Use entity-based templates to build hubs and spokes that search engines and humans can follow.

Hub and spoke prompt

Task: Build an entity hub and its spokes.

Inputs:
- {Entity} // e.g., "Network Monitoring"
- attributes: {
    "Capabilities": ["", "", ""],
    "Industries": ["", "", ""],
    "Integrations": ["", "", ""],
    "Alternatives": ["", "", ""]
  }
- sitemap_subset: [title, url]
- brand_rules: tone, words to avoid, internal link depth target

Outputs:
1) hub_intro: 120–160 words that frame the entity and who it serves
2) comparison_table: markdown table comparing Capabilities or Alternatives
3) alternative_pages: list of slugs, H1s, and one-line positioning for each alternative
4) glossary: 8–12 short definitions of key terms tied to {Entity}
5) internal_link_graph: suggested edges between hub and spokes with anchor text
6) breadcrumbs_rules: pattern for hub → category → spoke

Rules:
- Internal link anchors must be descriptive and unique.
- Each alternative page needs a distinct angle. If similarity >0.9 across two, propose a merge and canonical.
- Keep glossary definitions under 35 words.

Knowledge graph prompt to guide links and breadcrumbs

Task: Convert CSV attributes into a mini ontology and use it for linking.

Inputs:
- csv_rows: columns [entity, attribute_type, attribute_value]
- max_depth: 3

Outputs:
- ontology_json: nodes, edges, types
- linking_rules: how to select anchors and targets based on node proximity
- breadcrumb_patterns: patterns that reflect the ontology depth

Rules:
- Prefer links within 2 hops.
- Avoid orphan nodes; propose at least one inbound and one outbound link per node.

Dynamic page creation for SEO with AI

Content changes. Pages should keep up without breaking. This pattern supports incremental updates, pre-rendered output for bots, and performance targets - always serving the same content to users and crawlers.

Prompt for content diffs and incremental updates

Task: Compare current page content to upstream data and produce content diffs.

Inputs:
- current_page: { html: "...", last_updated: "YYYY-MM-DD" }
- new_data: { pricing: {...}, availability: {...}, features: [...], source_url: "" }
- constraints: { lcp_target_ms: 2500, image_max_kb: 200 }

Outputs:
1) diffs: list of { section_id, change_type: add|update|remove, before, after, rationale, needs_source? }
2) updated_alt_text: map of image filenames to concise alt text
3) priority_queue: ordered list of sections to publish first based on user impact
4) noindex_flag: true|false based on whether critical sections still need source
5) sitemap_update: true|false if URL structure changed
6) ssr_ssg_notes: recommend SSR or SSG based on change frequency
7) performance_notes: actions to stay under LCP target and image weight limits

Rules:
- Do not over-write unchanged sections.
- Flag any pricing changes as high priority.
- If facts lack sources, set noindex_flag = true.

Deployment notes

• Frameworks: Next.js for SSR when data changes often; Eleventy for SSG when it is mostly static.
• Pre-render for bots. Avoid heavy client-side rendering for primary content, and avoid cloaking.
• Queue-based publishing: apply diffs, run checks, then publish in batches.
• Auto-update XML sitemaps and ping search engines when batches go live.
• Performance guardrails: LCP under 2.5s on mobile, compress images, and lazy-load below-the-fold assets.

SEO template engineering for large websites

Model selection

• Generation: examples include Claude 3.5 or GPT-4o for higher factual accuracy and cleaner long-form. Try Claude or ChatGPT.
• Variants and rewrites: Llama 3.1 70B for lower-cost variants where risk is low.
• Embeddings: text-embedding-3-large or a compatible open model for similarity checks. Google's Gemini can also support related workflows.

For a deeper comparison of top models, see this in depth article about different LLMs here.

Cost and speed controls

• Cap tokens per page type. Example: 1.8k tokens body max, 500 tokens for extras.
• Run a dry batch of 20 pages and measure tokens per page to project cost.
• Cache common modules like FAQs and glossary stubs when appropriate.
• Schedule off-peak runs to reduce API throttling risk.

Use prompt patterns for better outputs

• Cognitive verifier: ask the model to list what it still needs before writing, then pause. Read the full conversation on ChatGPT
• Recipe sequence: Requirements, Preparation, Instructions, Troubleshooting, and Variations. Keep it short and literal. Read the full conversation in ChatGPT
• Fact-check checklist: highlight claims, confidence levels, and [needs source] tags. Read the full conversation on ChatGPT

For tradeoffs and pitfalls when using LLMs, see What Are the Limitations of Large Language Models (LLMs)?

QA gates to keep trust high

• Factuality via retrieval: force citations to {PrimarySourceURL} or your RAG index.
• Duplication via embeddings: block anything over 0.92 semantic similarity.
• Policy and brand checks: banned words, tone, compliance lines.
• Human spot-check ratio: at least 10 percent of new pages each cycle, with notes logged back into prompt refinements.

Measurement plan that ties to revenue

• Indexation rate by page type within 7, 14, and 28 days.
• Pixel-to-text ratio above the fold so content is actually visible.
• CTR movements on titles and rich results, tracked to the template version.
• Assisted conversions and pipeline value by landing page, not only last click.
• Revenue attribution window that matches the sales cycle, not a one-week snapshot.

Workflow I trust

• Brief: define the entity, audience, and intent stack.
• Prompt spec: write the system prompt and the page template with rules and outputs. For collaboration patterns, see the Ultimate Guide to AI Prompting Collaboration.
• Dry run: 20 pages through the pipeline with noindex.
• Evaluate: check titles, schema, internal links, and first-click data.
• Scale: roll across the rest of the set, batch by batch.
• Monitor: logs for failures, schema errors, and similarity conflicts. Update prompts monthly. If you need structure, try How To Organize AI Prompt Workflows.

Governance and versioning

• Add version keys to every prompt and schema output. Store diffs in Git.
• Maintain a changelog of prompt tweaks and why they happened.
• Separate prompts by function: generation, rewrite, schema, link graph, diffs.
• Run A/B tests at the template level, not only titles - for example, different proof mixes or FAQ counts.

Tooling setup that stays simple

• Data layer: Google Sheets or a warehouse table for inputs.
• Orchestration: a serverless function or a small job runner on your cloud of choice.
• Validation: schema check via headless run, length checks, and a small linter for banned words.
• CMS: anything with a JSON import endpoint and staging. Add a noindex flag field.
• Analytics: set up content grouping by template version so trends are obvious.

Where this all points

• Use programmatic SEO with LLMs to build repeatable systems, not one-off hacks.
• Adopt AI content templates for SEO at scale only when you can prove uniqueness and factuality on every page type.
• Keep the human in the loop where it matters most: truth, differentiation, and conversion logic.