Generative engine optimization is easier to understand when you see it in practice. Here are 5 companies that have published llms.txt files -- what they did well, how they structured them, and what you can steal for your own site.
GEO is not theoretical. Hundreds of companies have already published llms.txt files that make their sites readable by AI search engines. Some of these files are excellent. Some are mediocre. The difference between them is instructive.
We catalogued 840+ real llms.txt files in our Examples Directory. After analyzing them, clear patterns emerge in what separates the files that actually help AI understand a site from the ones that are just going through the motions.
Here are 5 generative engine optimization examples worth studying -- and the specific techniques that make each one effective.
1. Stripe -- The Gold Standard for Product Breadth
# Stripe > Stripe is a technology company that provides financial > infrastructure for businesses. Businesses of every size > -- from new startups to established public companies -- > use Stripe to accept payments online and in person, > embed financial services, and create custom revenue models. > For complete documentation in a single file, see > Full Documentation (stripe.com/llms-full.txt). ## Payments - [Stripe Payments](https://stripe.com/payments): Accept payments... - [Payment methods](https://stripe.com/payments/payment-methods): ... ## Billing - [Stripe Billing](https://stripe.com/billing): ... - [Usage-based billing](https://stripe.com/billing/usage-based-billing): ... ## Connect - [Stripe Connect](https://stripe.com/connect): ... ## Tax - [Stripe Tax](https://stripe.com/tax): ...
Clear company positioning
The blockquote immediately tells AI what Stripe is, who it serves (startups to public companies), and what it does (payments, financial services, revenue models). No marketing fluff.
Product-line sections
Each major product line -- Payments, Billing, Connect, Tax, Atlas -- gets its own H2 section. AI can quickly locate the right product when answering specific queries like "best usage-based billing tool."
llms-full.txt companion file
Stripe links to a full documentation dump at llms-full.txt. This two-file strategy gives AI a summary for quick understanding and a deep reference for detailed questions.
Consistent link descriptions
Every link includes a one-sentence description of what the page covers. AI uses these descriptions to decide which links are relevant to a specific query.
The takeaway: If your business has multiple product lines, give each one its own section. AI search engines answer specific queries -- "best subscription billing platform," "how to set up marketplace payments" -- and sectioned files let AI find the right answer without scanning your entire site.
2. Vercel -- Deep Documentation Hierarchy
# Vercel Documentation
[Vercel Documentation](https://vercel.com/docs): Vercel is
the AI Cloud -- a unified platform for building, deploying,
and scaling AI-powered applications and agentic workloads.
- [Getting Started](https://vercel.com/docs/getting-started-with-vercel)
- [Fundamental Concepts](https://vercel.com/docs/fundamentals)
- [Request Lifecycle](https://vercel.com/docs/fundamentals/infrastructure)
- [Build System](https://vercel.com/docs/fundamentals/builds)
- [Supported Frameworks](https://vercel.com/docs/frameworks)
- [Full-stack](https://vercel.com/docs/frameworks/full-stack)
- [Next.js](https://vercel.com/docs/frameworks/full-stack/nextjs)
- [SvelteKit](https://vercel.com/docs/frameworks/full-stack/sveltekit)
- [Nuxt](https://vercel.com/docs/frameworks/full-stack/nuxt)Nested indentation mirrors site architecture
Vercel uses indented lists to show parent-child relationships between docs pages. Frameworks > Full-stack > Next.js. AI understands this hierarchy and can navigate from general to specific.
Framework-specific sections
By listing every supported framework explicitly -- Next.js, SvelteKit, Nuxt, Remix, Astro, Vite -- Vercel appears in AI answers for framework-specific deployment queries. "How to deploy SvelteKit on Vercel" gets a direct link.
Positioned as "AI Cloud"
The description leads with "AI Cloud" -- a deliberate positioning choice. When someone asks AI about deploying AI applications, Vercel has planted the right language in the right place.
The takeaway: If you have extensive documentation, use indentation to create a browsable hierarchy. AI does not need every page listed at the same level. Nested structure tells AI which pages are overviews and which are deep dives -- and it can route users to the right depth based on their query.
3. GitHub Docs -- API-First Discovery
# GitHub Docs > Help for wherever you are on your GitHub journey. ## How to Use To find a specific article, use the Search API with a query. To browse all available pages, use the Page List API to get a list of paths, then fetch individual articles with the Article API. ## APIs - [Page List API](https://docs.github.com/api/pagelist/en/free-pro-team@latest) - [Article API](https://docs.github.com/api/article) - [Search API](https://docs.github.com/api/search/v1) - [Versions API](https://docs.github.com/api/pagelist/versions) ## Translations - [Spanish](https://docs.github.com/api/pagelist/es/...) - [Japanese](https://docs.github.com/api/pagelist/ja/...)
Instructions for AI agents
The "How to Use" section explicitly tells AI how to navigate the documentation. This is not written for humans browsing a website -- it is written for LLMs that need programmatic access to content. That is GEO in its purest form.
API endpoints instead of static links
Instead of listing hundreds of documentation pages, GitHub provides API endpoints that AI can query dynamically. The Page List API returns all article paths. The Article API fetches clean markdown. AI gets exactly the content it needs, nothing more.
Multi-language support
By listing translation endpoints, GitHub tells AI it can serve documentation in Spanish, Japanese, Portuguese, Chinese, and more. When someone asks AI a GitHub question in Japanese, AI knows where to find the answer.
The takeaway: GitHub's approach is the most advanced GEO example on this list. Instead of just listing pages, they built an API layer specifically for AI consumption. Most sites do not need this level of sophistication -- but the principle is transferable: think about how AI will consume your content, not just where it lives.
4. Supabase -- Modular Split by Audience
# Supabase Docs - [Supabase Guides](https://supabase.com/llms/guides.txt) - [Supabase Reference (JavaScript)](https://supabase.com/llms/js.txt) - [Supabase Reference (Dart)](https://supabase.com/llms/dart.txt) - [Supabase Reference (Swift)](https://supabase.com/llms/swift.txt) - [Supabase Reference (Kotlin)](https://supabase.com/llms/kotlin.txt) - [Supabase Reference (Python)](https://supabase.com/llms/python.txt) - [Supabase Reference (C#)](https://supabase.com/llms/csharp.txt) - [Supabase CLI Reference](https://supabase.com/llms/cli.txt)
One file per SDK language
Instead of cramming JavaScript, Dart, Swift, Kotlin, Python, and C# docs into one massive file, Supabase splits them into separate .txt files. AI can load only the language-specific reference it needs to answer a query.
Keeps the root file minimal
The root llms.txt is just 8 lines. It serves as a table of contents that points AI to the right sub-file. This is smart because LLMs have context limits -- sending a 50,000-line file wastes tokens and dilutes relevance.
Guides separated from references
Tutorials and conceptual guides live in guides.txt. API references live in language-specific files. This mirrors how developers actually search: "how to use Supabase auth" (guide) vs "supabase.auth.signIn() parameters" (reference).
The takeaway: If your documentation spans multiple SDKs, languages, or audiences, split your llms.txt into modular sub-files. Keep the root file as a routing layer. AI loads the root, identifies the right sub-file, and fetches only the content relevant to the query. Less noise, better answers.
5. Cursor -- Clean Structure for a Complex Product
# Cursor Documentation ## Get Started - https://cursor.com/docs.md - https://cursor.com/docs/get-started/quickstart.md - https://cursor.com/docs/models-and-pricing.md ## Agent - https://cursor.com/docs/agent/overview.md - https://cursor.com/docs/agent/plan-mode.md - https://cursor.com/docs/agent/prompting.md - https://cursor.com/docs/agent/tools/terminal.md ## Customizing - https://cursor.com/docs/plugins.md - https://cursor.com/docs/rules.md - https://cursor.com/docs/skills.md - https://cursor.com/docs/mcp.md ## Cloud Agents - https://cursor.com/docs/cloud-agent.md - https://cursor.com/docs/cloud-agent/setup.md
Markdown file links (.md)
Cursor links directly to .md versions of their docs pages. This tells AI to fetch clean markdown instead of rendered HTML -- less parsing overhead, better content extraction, fewer layout artifacts confusing the response.
Feature-based sections
Sections are organized by what users do: Get Started, Agent, Customizing, Cloud Agents, Integrations. When someone asks AI "how to use Cursor agent mode," AI can jump directly to the Agent section.
Pricing alongside features
models-and-pricing.md is linked in the Get Started section. When someone asks "how much does Cursor cost" or "which AI models does Cursor support," AI has the answer immediately without crawling the marketing site.
The takeaway: Cursor is a fast-moving product with an AI code editor, cloud agents, MCP integrations, and custom rules. Their llms.txt keeps it organized by mapping features to documentation pages. If your product evolves quickly, this structure makes it easy to add new sections without restructuring the entire file.
Patterns Across All 5 GEO Examples
These five companies operate in different markets, serve different audiences, and have different documentation strategies. But their llms.txt files share patterns that are worth extracting:
Structure matches user intent
Every file organizes content around how people search, not how the company is structured internally. Product sections, feature sections, use-case sections -- not "About Us" and "Resources."
Descriptions do the heavy lifting
The blockquote and link descriptions tell AI what each page covers. Without descriptions, AI has to guess from the URL or page title. With descriptions, AI can match queries to pages with confidence.
Scale is managed intelligently
None of these companies dump their entire sitemap into llms.txt. Stripe uses a full.txt companion. Supabase splits by language. GitHub provides APIs. They manage scale without overwhelming AI context limits.
Pricing and positioning are explicit
Every file includes pricing information or clear product positioning. AI cannot recommend you for budget-specific or use-case-specific queries if it does not know what you cost or who you serve.
How to Find More GEO Examples
These 5 are some of the strongest generative engine optimization examples we have seen, but they are not the only ones. Our Examples Directory catalogues 840+ sites that have published llms.txt files, across industries from developer tools to e-commerce to media.
Each entry in the directory shows the site's llms.txt structure, section count, link count, and a quality breakdown. You can browse by category, sort by quality score, and click through to see the actual llms.txt file.
Studying how other sites in your industry structure their llms.txt is one of the most practical things you can do for GEO. If a competitor has already published one, look at what sections they included, what descriptions they wrote, and what content they prioritized. Then build yours to be more thorough.
Start with Your Own AI Readiness Check
The companies in this article have teams dedicated to documentation and developer relations. But the principles work at any scale. A well-structured llms.txt with clear descriptions and logical sections helps AI understand a 10-page portfolio site just as effectively as it helps Stripe's documentation library.
The first step is understanding where you stand. An AI Readiness Check audits your site across 5 factors -- llms.txt, robots.txt, structured data, sitemap, and crawler access -- and tells you exactly what AI search engines can and cannot see. Free. 30 seconds. No signup.
See how AI-ready your site is
Run a free AI Readiness Check. See what AI search engines can see -- and what they are missing.
Check your AI readiness →