We audited 12 framework starter templates. 11 ship zero structured data.

Almost nobody writes a website from an empty directory any more. You run create-next-app, or clone a theme, or fork the docs starter — and whatever that template ships with becomes the baseline your site inherits for years. Performance defaults get a lot of attention in framework marketing. The markup that decides whether a search engine or an AI assistant can understand your page gets almost none.

So we pointed our own audit engine at the starters themselves. Twelve publicly deployed official templates and demo sites across Next.js, Astro, SvelteKit and Nuxt, plus Gatsby and Eleventy as a static-site-generator control group. 85 pages crawled in total, on 10 August 2026. Every number below came out of the same crawler that runs behind our SEO and AEO audit — no hand-scoring, no cherry-picking.

The short version: on answer-engine readiness the starters are nearly indistinguishable from each other, and nearly all of them are missing the same three things.

Methodology

The engine is a fetch-and-parse crawler (no JavaScript execution) running 41 checks: 24 per-page and 11 site-wide, plus a set of probes for robots.txt, sitemap.xml, llms.txt, favicon.ico and a synthetic 404. Nine of those checks are the AEO subset — the ones about whether a machine that is not a browser can understand and cite the page: structured data present, structured data parseable, snippet restrictions, llms.txt, Organization schema, thin content, FAQ-schema opportunity, content freshness signals, and meta robots directives.

Two scores come out of a run. The SEO score starts at 100 and subtracts per distinct issue — 10 for a critical, 4 for a warning, 1 for a notice. The AEO readiness score is the identical calculation applied to the AEO subset only. Each site was crawled with a cap of 10 pages (breadth-first from the homepage, same-origin links only) at a concurrency of 3, with a 20-second per-request timeout.

• Next.js — the blog-starter example, Next.js Commerce (ACME Storefront), and the Next.js Learn dashboard.
• Astro — the official blog starter template, and the Starlight docs starter.
• SvelteKit — the RealWorld reference app (Conduit), and a widely-forked SvelteKit starter boilerplate.
• Nuxt — the Alpine theme, Docus (the Nuxt docs starter), and the Nuxt Content documentation site.
• Control group — the Gatsby starter blog, and Eleventy base blog v9.

Three honest limits on what follows. First, the crawl depth is not uniform: some of these deployments only have one or two same-origin pages to find, so a single-page crawl gets fewer chances to trip a per-page check than a twelve-page crawl does. Second, the score subtracts per distinct issue rather than per affected page, so a deeper crawl that surfaces four differently-worded thin-content findings loses more points than a shallow one — Eleventy scores lowest partly because we crawled twelve of its pages. Third, none of this is a judgement of the frameworks. A starter is deliberately minimal, and every gap below is a two-line fix. The point is that almost nobody makes those two-line fixes, because the template never told them to.

Finding 1: 11 of 12 ship no structured data at all

The check is as simple as it gets — is there at least one parseable script tag of type application/ld+json on the page? Eleven of twelve templates have none, on every page we crawled. Not invalid schema, not incomplete schema: none.

This matters more in 2026 than it did in 2020. JSON-LD is what turns a page from a wall of text into a set of typed facts — this is an Article, published on this date, by this Organization, about this Product at this price. Rich results depend on it, and so does citation by AI answer engines, which have far less patience for inferring structure from your heading hierarchy than a decade-tuned search crawler does. A page with no structured data is not penalised; it is just less legible, and legibility is the entire game when something else is writing the summary.

The one template that passes is Docus, the Nuxt documentation starter, which emits JSON-LD on every page out of the box. Adding it yourself is a script tag — for a blog post, this is the whole fix:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "What actually breaks Core Web Vitals in 2026",
  "datePublished": "2026-07-19",
  "dateModified": "2026-07-19",
  "author": { "@type": "Organization", "name": "RankVitals" }
}
</script>

If you add it, validate it — a JSON-LD block with a trailing comma is worth exactly as much as no JSON-LD block, and nothing in your build will tell you. Our structured data checker parses what your live URL actually serves, which is the only copy that counts.

Finding 2: 10 of 12 have no llms.txt

llms.txt is the newest thing we check for and the least settled: a plain-Markdown file at the root that tells a language model what your site is and where the canonical explanations live, in the same spirit as robots.txt but aimed at comprehension rather than permission. It is a convention, not a standard, and no engine is obliged to read it.

We flag it as a notice rather than a warning for exactly that reason. But it is a five-minute file with an asymmetric payoff, and it is telling which two templates already ship one: Docus and the Nuxt Content docs — both documentation starters, both from an ecosystem that decided early that being machine-readable was part of being a docs framework. Every general-purpose starter in the set skips it.

If you write one, keep it a genuine map rather than a marketing page: an H1 with the product name, a blockquote of what it does, then linked sections pointing at your real documentation URLs. Our llms.txt generator will draft one from a site you already have.

Finding 3: 10 of 12 never say who publishes the site

The Organization schema check looks for a site-wide Organization or LocalBusiness entity — the machine-readable answer to "who is this?". Ten templates never answer it. Combined with finding 1, the average starter publishes content that has no stated author, no stated publisher, and no stated type.

That is a strange position for a site whose whole purpose is to be found, and it is one JSON-LD block in your root layout, written once and inherited by every page. Pair it with a WebSite entity and you have covered the two entities that every other piece of schema on your site will eventually reference.

The scores

AEO readiness across the twelve ran from 86 to 99, median 93, mean 92.8 — a spread of thirteen points across four frameworks and two static-site generators. That tight clustering is itself the result: on answer-engine readiness the choice of framework barely matters, because every template is missing roughly the same things. Full table, as AEO readiness / SEO score / pages crawled:

• Docus (Nuxt docs starter) — 99 / 62 / 10 pages. The only template with structured data, Organization schema and llms.txt all present.
• Next.js blog-starter — 94 / 60 / 4 pages.
• Next.js Learn dashboard — 94 / 71 / 2 pages.
• Nuxt Content docs — 94 / 52 / 10 pages. Has llms.txt and Organization schema, but not JSON-LD on every page.
• Astro blog starter template — 93 / 75 / 1 page.
• Astro Starlight docs starter — 93 / 54 / 11 pages.
• Nuxt Alpine theme — 93 / 40 / 7 pages. Lowest SEO score in the set.
• Gatsby starter blog — 93 / 82 / 1 page. Highest SEO score in the set.
• Next.js Commerce (ACME Storefront) — 92 / 48 / 10 pages.
• SvelteKit starter boilerplate — 92 / 56 / 7 pages.
• SvelteKit RealWorld (Conduit) — 90 / 48 / 10 pages.
• Eleventy base blog v9 — 86 / 45 / 12 pages. Deepest crawl in the set, which costs it points (see the methodology caveat).

The wider SEO picture is worse than the AEO one

AEO scores clustered in the nineties because only nine checks feed them and the failures are consistent. The full 41-check SEO score is far more brutal: median 55, range 40 to 82. The recurring failures, counted as the number of templates affected out of twelve:

• Title-tag length outside the 30–60 character band — 11 templates. Usually far too short: a two-word page title carries almost no query surface.
• No sitemap.xml discoverable, either declared in robots.txt or at the default path — 9.
• Missing canonical tags — 9. On a template that will eventually serve the same content under a trailing slash, a query string and a pagination parameter, this is the cheapest duplicate-content insurance there is.
• Images in legacy formats with no WebP or AVIF alternative — 8.
• No robots.txt at all — 8.
• Meta descriptions outside the 70–160 character band, or missing — 8 and 3 respectively.
• Incomplete Open Graph tags — 7, which is why so many template-based sites paste into Slack as a bare grey link.
• Likely below-the-fold images without loading="lazy" — 7.
• No BreadcrumbList schema — 7.

// Next.js App Router: canonical + Open Graph for every page, written once
export const metadata: Metadata = {
  metadataBase: new URL('https://example.com'),
  alternates: { canonical: '/' },
  openGraph: { type: 'website', siteName: 'Example', images: ['/og.png'] },
};

None of these are hard. That is the uncomfortable part: the median starter template loses roughly forty-five points to problems that are each one attribute, one tag or one file. If you are on Next.js or Astro specifically, our Next.js speed guide and Astro speed guide cover the framework-specific versions of the fixes above.

What this study cannot tell you

The crawler fetches HTML and parses it; it does not execute JavaScript. For a starter template that is close to harmless — every one of these deployments server-renders its markup, which is why the structured-data finding is trustworthy — but a client-only SPA that injects JSON-LD after hydration would be scored unfairly, and Googlebot would eventually see markup we did not. If your site renders its head client-side, treat our numbers as a floor.

It also cannot tell you about ranking. Nothing here measures traffic, position or citation rate, and we would not believe anyone who claimed a twelve-site sample could. What it measures is legibility: whether the facts a machine needs are actually present in what you serve. Everything downstream of that is somebody else’s algorithm.

And it is a snapshot. These are live deployments that get updated; the numbers are from 10 August 2026 and a template that fails today may ship the fix tomorrow. The methodology above is deliberately reproducible so you can check.

Run it on your own site

The three findings collapse to one sentence: your starter almost certainly gave you a fast page that says nothing about itself. Fix the three — a JSON-LD entity per page type, an Organization entity in the root layout, an llms.txt at the root — and you are ahead of eleven of the twelve templates most sites are built from. The same crawl that produced this study runs on any public URL, free, and reports the same checks with the offending pages attached. It pairs with a Lighthouse run in the same test, so you get the speed number and the legibility number together — the two halves of what we built the product to do.

FAQ

Is AEO just SEO with a new name?

They overlap heavily and diverge at the edges. Classic SEO cares about crawlability, relevance and links; AEO cares about whether a machine that will paraphrase your page can extract typed facts from it — structured data, an identifiable publisher, clear freshness signals, content substantial enough to be worth quoting. Our audit scores them separately for that reason: a site can rank fine and still be nearly impossible to cite accurately.

Does llms.txt actually do anything yet?

No engine is obliged to read it, and we score it as a notice rather than a warning to reflect that. The argument for writing one is cost: it is a Markdown file listing your canonical documentation URLs, it takes minutes, and if adoption continues you already have it. The argument against is that it can drift out of date and then actively misinform — so treat it as a document you maintain, not a file you generate once.

Why did a template with a great SEO score get a mediocre AEO score?

They measure different things and are computed from different check sets. The Gatsby starter blog scored 82 on SEO and 93 on AEO; the Nuxt Alpine theme scored 40 on SEO and 93 on AEO. A site can have clean titles, descriptions and canonicals — the classic SEO hygiene — while still shipping no structured data and no publisher identity, which is precisely the pattern we found almost everywhere.

Can I reproduce these numbers?

Yes, and that is the point of the methodology section. The corpus is twelve named public deployments, the crawl budget was 10 pages breadth-first from the homepage at concurrency 3, and the checks and scoring weights are described above. Run the same audit on the same URLs and you should land in the same place, modulo whatever the template authors have shipped since 10 August 2026.