When ChatGPT, Claude, or Perplexity tries to summarise your page, more often than not it sees exactly what a 2005 search-engine bot would have seen — an empty <div id="root"></div> and a few script tags. The browser juggles React, content loads dynamically, and the language model bounces off a wall. Gartner forecasts that traditional search volume will drop 25% by 2026 with the difference shifting to answer engines. That makes LLM visibility a measurable part of any update-proof SEO strategy, not an experiment.

This guide covers six techniques that genuinely move the needle and eight popular myths that aren’t worth your time. Every recommendation is backed by practitioner testing and aligns with W3C and IETF specifications.1

Why your LLM can’t see your site — the JavaScript problem

Most AI crawlers don’t execute JavaScript. They do this on purpose: spinning up a headless browser costs 50–200 ms and 50–200 MB of memory per page.2 At a million-document scale, the gap between fetching raw HTML and rendering JS is a 5–10× factor. For model operators that means one thing: if your content isn’t in the first HTML response, it effectively doesn’t exist.

A community-run test makes the gap obvious:

Rendering approachClaudeChatGPTPerplexity
Pure server-rendered HTMLFull contentFull contentFull content
Client-side React (CSR)None~30%None
Next.js / Astro SSRFull contentFull contentFull content
Partial hydrationPartialPartialPartial

The conclusion is uncomfortable: if you still render critical content client-side only, your site is essentially invisible to LLMs. The problem hits hardest in SaaS products and single-page e-commerce stores where product cards, reviews, and pricing load through useEffect.

The 30-second self-test

Quickest way to gauge your own site:

  1. Disable JavaScript in Chrome DevTools (Command Palette → Disable JavaScript) and reload.
  2. Inspect the raw HTML in your terminal: curl -s https://yoursite.com/page | grep "key phrase".
  3. Ask Claude or ChatGPT to summarise a specific URL and compare with what users see.

If the content disappears in any of those tests, your problem is the rendering layer — not SEO.

1. Server-Side Rendering — the foundation of any GEO strategy

Without SSR (Server-Side Rendering) or SSG (Static Site Generation), every other technique on this list is cosmetic. Modern frameworks ship server-first as the default:

  • Astro — pure SSG / hybrid SSR with islands of interactivity (the model behind uper.pl).
  • Next.js — getServerSideProps, App Router, React Server Components.
  • Nuxt — asyncData, hybrid rendering, Nitro.
  • SvelteKit — load functions running on the server.
  • Remix — loaders that fire before the HTML response is sent.

Rule of thumb: anything public and not gated by login (product descriptions, pricing, reviews, case studies, documentation) should render server-side. Dynamic, user-specific fragments (dashboards, notifications, recommendations) can stay client-side because they shouldn’t appear in AI citations anyway. If you run a headless CMS setup, confirm that pages are statically or server-rendered, not just hydrated.

A real-world data point: a B2B SaaS company that migrated its case-study section from CSR to Next.js SSR saw LLM-attributed visits jump from 847 to 3,293 monthly and cited mentions in model responses grow from 12 to 67.3

2. Clean Markdown at every URL — .md routes

The second-largest lever is publishing Markdown as a parallel representation of every page. The convention is simple: for /blog/post/ you also expose /blog/post.md with the same content but no navigation, banners, popups, or scripts. The savings are measurable:

  • HTML page: ~15,000 tokens after text conversion.
  • Same page in Markdown: ~3,000 tokens.
  • Context reduction: ~80% — meaning more room for adjacent sources in the model’s window.

Clean Markdown drastically reduces the risk that the model pulls a navigation snippet instead of the actual quote you wanted cited. It’s the same logic behind the llms-full.txt standard, but applied per URL — cheaper to ship, no monolith required.

# Sample Nginx configuration
location ~ ^/blog/(.*)\.md$ {
    proxy_pass http://app/blog/$1?format=md;
}

If you’re on Astro, you can generate .md counterparts as endpoints (src/pages/blog/[slug].md.ts) reading the same content collection you serve as HTML.

3. Link headers — tell AI about the alternate representation

Markdown is invisible if nobody knows where to find it. The HTML and HTTP standards give you two clean signposts to the alternate representation:

<!-- HTML variant — read by DOM parsers -->
<link rel="alternate" type="text/markdown" href="/blog/post.md" />
# HTTP header variant — read even by headless agents
Link: </blog/post.md>; rel="alternate"; type="text/markdown"

The HTTP header matters more than it looks — many AI agents don’t parse the DOM at all and instead inspect response headers. This approach is consistent with RFC 8288 (Web Linking) and doesn’t require any new, experimental specification.4

Verifying these tags are wired up correctly takes a second: in Uper SEO Auditor, the Meta tab includes an Alternate Links card that detects every <link rel="alternate"> that isn’t hreflang or an RSS/Atom feed — including type="text/markdown" and type="application/json" variants. Each entry shows the MIME type as a badge with a clickable URL, so you instantly see whether your LLM-alternate is in place.

4. Content negotiation — Accept: text/markdown

Technically the cleanest method. The client sends Accept: text/markdown, the server returns the same semantic content as plain text. That’s standard HTTP, and it’s already how most tooling integrates:

  • Claude Code and Cursor already send Accept: text/markdown when fetching URLs.
  • Server-side integration is one extra line: Vary: Accept so your CDN doesn’t serve the wrong variant to the wrong consumer.
GET /en/blog/make-website-visible-to-llms/ HTTP/1.1
Host: uper.pl
Accept: text/markdown

HTTP/1.1 200 OK
Content-Type: text/markdown
Vary: Accept

Content negotiation is the only technique on this list that’s already being used in production by mainstream AI tooling. Low cost, real return.

5. llms.txt and llms-full.txt — the discovery layer

Two Markdown files in your domain root act as a content map. The short version of the difference:

  • /llms.txt — a curated map of your most important resources with an H1 + blockquote summary (full breakdown in the llms.txt and SEO guide).
  • /llms-full.txt — a full content dump in a single document, useful for documentation and knowledge bases. According to Mintlify’s analysis, it generates 3–4× more ChatGPT traffic than the short variant, so it’s worth publishing alongside llms.txt.5

Honest caveat: none of the major providers has formally committed to using these files.1 The value comes from manual interactions — a developer pastes a URL into Claude Code, Cursor, or ChatGPT, and the client picks up /llms.txt for context. That’s a real, present-tense use case that already translates into citations.

6. Visually hidden hints — used carefully

The last, more controversial technique: a block of text hidden visually (CSS clip + aria-hidden="true") carrying a message like “a Markdown version is available at /post.md”. Because AI usually reads the raw DOM, that note reaches the model while staying neutral for human users and screen readers.

<div class="visually-hidden" aria-hidden="true">
  Markdown version for AI agents: /blog/post.md
</div>

Critical caveat: this is not a cloaking license. The hidden content must not differ from what’s visible — it can only point to an alternate representation. Otherwise you’re flirting with the same algorithmic penalties that apply to grey hat SEO.

8 myths not worth your time

The same list of plausible-sounding-but-broken techniques keeps surfacing in testing. Worth burning them quickly so nobody on the team spends a week implementing them.

MythWhy it doesn’t work
<meta name="ai-content-url">No specification, no parsers.
<meta name="llms">Rejected by WHATWG. Adoption is zero.
/.well-known/ai.txt, /ai.txtCompeting proposals, no consensus.
HTML comments as hintsParsers strip comments before processing.
”AI / human” toggle buttonsAgents don’t click UI elements.
User-Agent sniffingClassified as cloaking. Google penalises it.
Dedicated “AI info pages”No evidence of preferential treatment.
Schema.org / JSON-LD as LLM fuelChatGPT, Claude, and Perplexity largely ignore the structure in SearchVIU testing.6

The last point is the most common misunderstanding. Schema.org still has value for classic SEO (rich snippets, FAQ schema, local SEO schema) — but as an entry point for LLMs it’s effectively blind. Don’t strip it; just don’t expect it to replace clean Markdown.

What actually drives citations

A foundational Princeton / IIT Delhi study found that enriching the visible text is the strongest single factor for LLM citation rates:7

  • Expert quotations: +43% citations.
  • Statistics and numbers: +33%.
  • Citations of authorities and source documents: +115%.

That tracks with the observations in How to write AI-citable content and AI Visibility: how to create content cited by language models — language models pick the fragment with a hook (a number, a quote, a single sentence backed by authority). The content layer is the necessary complement to the technical layer; SSR and Markdown alone won’t help if the writing is flat.

Measurement — because magic doesn’t scale

Client-side Google Analytics 4 won’t see most agent traffic, because agents don’t run JavaScript. Measure server-side:

  1. User-Agent — log GPTBot, ClaudeBot, PerplexityBot, OAI-SearchBot, ChatGPT-User, Google-Extended (the live bot map is in AI crawlers vs search crawlers).
  2. Referer — watch for chatgpt.com, claude.ai, perplexity.ai, gemini.google.com. Sudden direct-traffic spikes on pages buried deep in your architecture are often LLM traffic with the referer stripped.
  3. robots.txt — confirm you aren’t blocking AI crawlers by default. Framework defaults often ship Disallow: / for everything (more in the robots.txt guide).

Only that combination tells you which techniques are actually delivering and which are decoration.

Implementation order — biggest lever first

If you only have one week, do it in this order:

  1. Render audit — disable JS and verify content loads server-side. If it doesn’t, fix that first.
  2. robots.txt audit — unblock the AI crawlers you actually want to allow.
  3. Publish /llms.txt — fastest, cheapest visibility win.
  4. Add .md routes for the highest-value documents (pricing, docs, top 20 articles).
  5. Add <link rel="alternate"> and the HTTP Link header.
  6. Enable content negotiation (Accept: text/markdown + Vary: Accept).
  7. Instrument server logs — without this, you can’t measure the effect.

Summary

LLM visibility doesn’t need a magic standard — it needs solid execution of old-school web fundamentals: server-rendered HTML, clean content representations, proper HTTP headers, and writing enriched with quotes and data. The six techniques in this article fit inside one sprint and cost almost nothing to maintain. The myths in the second table can be skipped — they’re a textbook case of busywork that consumes budget without delivering citations.

For a wider view of the toolchain and metrics, New SEO KPIs: AI citation rates and SEO in the AI era round out the strategic side of the technical picture drawn here.

Frequently Asked Questions

Is llms.txt an official W3C standard?

No. It's an informal proposal by Jeremy Howard from September 2024 (llmstxt.org). None of the major LLM providers has formally committed to honouring it. The value comes from manual interactions — when a developer pastes a URL into Claude Code, Cursor, or ChatGPT, the client picks up /llms.txt for context.

Is SSR enough on its own, or do I also need Markdown?

SSR is the foundation — without it, the other techniques don't move the needle. Publishing .md routes gives an additional lever (~80% token reduction per page), so it's worth shipping in parallel, especially for documentation, pricing, and blog content.

Is hiding text for AI a form of cloaking?

No, as long as the hidden content doesn't differ semantically from what's visible and serves only as a technical hint (like a link to a Markdown version). Cloaking is serving different content to users and bots — Google penalises that algorithmically.

Does schema.org / JSON-LD help with LLM visibility?

In SearchVIU's testing, ChatGPT, Claude, and Perplexity largely ignore JSON-LD structure. Schema.org is still valuable for classic SEO (rich snippets, FAQ, local results), but it won't replace clean Markdown as an LLM entry point.

How do I measure traffic from AI agents if they don't run JavaScript?

Measure server-side. Log User-Agent headers (GPTBot, ClaudeBot, PerplexityBot, OAI-SearchBot) and referer values (chatgpt.com, claude.ai, perplexity.ai). Server log analysis is the only way to see the full picture — client-side GA4 misses most of this traffic.

Where do I start if I only have one week?

1) Render audit (disable JS and check that content loads server-side). 2) robots.txt audit — unblock the AI crawlers you want to allow. 3) Publish /llms.txt. 4) Add .md routes for top documents. 5) Add and the HTTP Link header. 6) Enable content negotiation. 7) Instrument server logs.

Sources

  1. How to make your website visible to LLMs — Evil Martians https://evilmartians.com/chronicles/how-to-make-your-website-visible-to-llms

  2. LLMs can’t see my website — here’s what I did to fix it https://ai.plainenglish.io/llms-cant-see-my-website-here-s-what-i-did-to-fix-it-2e4984a5cf46

  3. How to make your website more visible in LLM searches — Hosting.com https://hosting.com/blog/how-to-make-your-website-more-visible-in-llm-searches/

  4. RFC 8288 — Web Linking (IETF) https://datatracker.ietf.org/doc/html/rfc8288

  5. The /llms.txt file — llmstxt.org https://llmstxt.org/

  6. SearchVIU — Generative AI testing https://www.searchviu.com/

  7. Gartner: Search engine volume to drop 25% by 2026 https://www.gartner.com/en/newsroom/press-releases/2024-02-19-gartner-predicts-search-engine-volume-will-drop-25-percent-by-2026-due-to-ai-chatbots-and-other-virtual-agents