Akbo Ichou

Posted on Sep 25

How I Structured a 21,000-Page AI Prompt Library for SEO (Without It Turning Into Thin Content)

#seo #ai #webdev #nextjs

Programmatic SEO has a bad reputation, and mostly for good reason: thousands of near-identical pages with a keyword swapped in. When I built AI Prompts Online — a free library of copy-ready prompts for ChatGPT, Claude, Gemini, Midjourney, Sora, Runway, Pika, DALL·E, Stable Diffusion and Suno — I wanted the scale of programmatic pages without the thinness.

The library now has about 21,000 unique pages across 10 tools and 15 categories. Here's how it's put together.

One prompt = one tool + one job

The core unit is simple: a reusable brief for one AI tool doing one job. That constraint matters because text, image, video and music models want very different prompt shapes:

Text models (ChatGPT, Claude, Gemini): role, context, constraints, steps, output format.
Image models (Midjourney, DALL·E, Stable Diffusion): subject, composition, lighting, style, aspect ratio.
Video models (Sora, Runway, Pika): shot type, camera motion, duration, continuity.
Audio (Suno): genre, tempo, instrumentation, structure.

A "universal prompt" template would have produced generic pages. Per-tool shapes make each page actually useful.

Predictable routes

Every prompt lives at a lowercase, hyphenated path:

/prompts/{tool}/{category}/{slug}

For example /prompts/chatgpt/code-generation/auth-middleware. Tool hubs explain the tool and link into categories; category hubs link into prompts. That hierarchy gives crawlers (and humans) a clean path from broad to specific.

A content contract every page must pass

The thing that keeps 21k pages from becoming spam is a written spec that every page has to satisfy before it ships:

A direct 40–60 word answer at the top.
A unique H1 and meta description.
At least 300 words of body copy.
A FAQ section.
Five or more internal links.

I keep this in the repo as a single markdown file and treat it like a linter for content. A small validation step makes it enforceable:

type PromptPage = {
  h1: string;
  metaDescription: string;
  answer: string;
  body: string;
  faq: { q: string; a: string }[];
  internalLinks: string[];
};

const words = (s: string) => s.trim().split(/\s+/).length;

export function validate(page: PromptPage): string[] {
  const errors: string[] = [];
  const a = words(page.answer);
  if (a < 40 || a > 60) errors.push(`answer is ${a} words (want 40–60)`);
  if (words(page.body) < 300) errors.push("body under 300 words");
  if (page.faq.length === 0) errors.push("missing FAQ");
  if (page.internalLinks.length < 5) errors.push("fewer than 5 internal links");
  return errors;
}

Uniqueness of H1s and metas is checked across the whole catalog at build time, not page by page.

No images on prompt pages (on purpose)

Prompt pages skip images entirely. They're text products — the copy block is the thing people want — so images would only add weight, hosting cost and slower loads. Category pages can carry a single optional banner later if it earns its place.

Split sitemaps + hourly revalidation

With this many URLs, one giant sitemap is painful to debug. I split them into three groups:

Static pages
Category hubs
Prompt pages

Pages use incremental static regeneration with hourly revalidation, so they're served fast from cache while lastmod values in the sitemaps stay fresh:

// app/prompts/[tool]/[category]/[slug]/page.tsx
export const revalidate = 3600; // one hour

Tools that grow the library

Besides the static catalog there are three interactive tools:

Prompt generator — pick a tool, category and goal; it calls a model (with a local fallback if the model isn't available) and can save the result as a new library page.
Prompt enhancer — paste a weak draft and get back a role, constraints, steps and an output contract.
Random prompt — a quick starting point instead of a blank chat.

Saving generated prompts is gated on a database being configured, so the site still works fine as a purely static catalog in environments without one.

Lessons

Programmatic pages are fine if each one passes a real quality bar — write that bar down and enforce it in code.
Model the domain honestly: different AI tools need different prompt structures.
Clean URL hierarchies and split sitemaps make a large site much easier to operate.
Drop anything (like images) that doesn't serve the page's actual job.

If you want to poke around or grab a prompt, it's at aipromptsonline.com — no account needed. I'm curious how others have handled quality control for large programmatic sites.

DEV Community