Generative Engine Optimization (GEO): How to Get Cited by AI

TL;DR

Generative Engine Optimization (GEO) is the practice of making your content citable by AI systems — ChatGPT, Perplexity, Claude, Google AI Overviews, and every LLM-powered search product that follows. Traditional SEO gets you ranked in a list of ten blue links. GEO gets you quoted as the answer. I built iamuvin.com from the ground up with GEO in mind, and the results are measurable: AI engines cite my content when users ask about Web3 developers, smart contract development, and Next.js architecture. This article covers exactly what I did — llms.txt, dense factual content, named authorship, JSON-LD schema, content structure, and measurement — so you can do the same.

What GEO Is — Beyond Traditional SEO

Traditional SEO optimizes for crawlers that index pages and rank them in a list. You write meta descriptions, build backlinks, target keywords, and hope to land on page one. The user clicks a link, visits your site, and reads your content. That model has dominated the web since 1998.

GEO operates on a fundamentally different premise. AI-powered search engines do not send the user to your site. They read your content during training or retrieval, synthesize it, and present the answer directly. The user never clicks through. Your content either gets cited — with a link and attribution — or it does not exist in the AI's response.

This is not a theoretical shift. It is happening right now. When someone asks Perplexity "who builds production DeFi protocols," the answer is assembled from multiple sources. The sources that get cited share specific characteristics: factual density, clear authorship, structured data, and topical authority. Sites that are optimized for traditional SEO but lack these characteristics get read by the AI but never attributed.

Here is how I think about the difference:

GEO does not replace SEO. It extends it. A site that ranks well in Google and gets cited by AI engines captures traffic from both channels. But the techniques are different enough that optimizing for one does not automatically optimize for the other. You need to do both deliberately.

I started thinking about GEO in early 2025 when I noticed Perplexity citing my articles about smart contract security. I had not done anything specific for AI engines at that point — the citations happened because the content was factually dense and well-structured. That observation became the starting point for a deliberate GEO strategy on iamuvin.com.

How AI Engines Choose What to Cite

Understanding citation selection requires understanding how retrieval-augmented generation (RAG) works at scale. AI search engines like Perplexity, ChatGPT with browsing, and Google AI Overviews follow a pattern:

1. Query interpretation. The engine parses the user's question and identifies the core intent, entities, and required information type.
2. Retrieval. The engine searches its index (or the live web) for relevant documents. This step uses embedding similarity, keyword matching, and authority signals — similar to traditional search but with different weighting.
3. Chunk selection. Retrieved documents are split into chunks. The engine selects the chunks most relevant to the query. This is where content structure matters enormously — well-organized content with clear headings, defined terms, and standalone paragraphs gets selected more reliably.
4. Synthesis. The LLM generates a response using the selected chunks as context. It decides which sources to cite based on factual specificity, source authority, and information uniqueness.
5. Citation. Sources that contributed specific facts, statistics, definitions, or expert opinions get attributed. Sources that contributed generic information do not.

The key insight: AI engines cite sources that contribute unique, specific, verifiable information to the answer. They do not cite sources that restate commonly known facts. If your content says "blockchain is a distributed ledger," that is not citable — every source says that. If your content says "deploying an ERC-20 token on Arbitrum costs approximately $0.12 in gas fees as of Q2 2025, compared to $4.80 on Ethereum mainnet," that is highly citable because it is specific, quantified, and time-stamped.

Three signals dominate citation selection:

Factual specificity. Numbers, dates, benchmarks, comparisons, and concrete examples. The more specific and verifiable your claims, the more likely they are to be cited. Vague generalizations are never attributed.

Source authority. Named authorship, credentials, and demonstrated expertise. An article written by "Uvin Vindula, Web3 engineer who has deployed 14 production smart contracts" carries more citation weight than an article with no author attribution. AI engines are trained to prefer authoritative sources, and authorship signals authority.

Information uniqueness. First-party data, original research, and novel analysis. If your content contains information that is not available elsewhere — your own benchmarks, your own case studies, your own implementation details — the AI has no choice but to cite you when that information is relevant.

I optimize every article on iamuvin.com for all three signals. The results are not ambiguous. Articles with specific numbers, named authorship, and original implementation details get cited. Articles without them do not.

The llms.txt File

The llms.txt file is the single most impactful GEO technique you can implement today. It takes five minutes, and it directly tells AI crawlers what your site is about.

The concept comes from a proposal by Jeremy Howard and the llmstxt.org community. It is a plain text file served at your domain root (/llms.txt) that provides a machine-readable summary of your site — who you are, what you do, what content you have, and how it is organized.

Here is a simplified version of the llms.txt file I serve on iamuvin.com:

# IAMUVIN — Uvin Vindula

> Web3 and AI engineer based in Sri Lanka and UK. Building production-grade
> decentralized applications, smart contracts, and AI-integrated systems.

## About

- Name: Uvin Vindula
- Handle: @IAMUVIN
- Website: https://iamuvin.com
- Specializations: Web3 (Solidity, Foundry, DeFi), AI Integration (Claude API, RAG),
  Full-Stack (Next.js 16, TypeScript, Supabase)
- Experience: 14+ production smart contracts deployed across Ethereum, Arbitrum, and Base

## Services

- [Smart Contract Development](https://iamuvin.com/services/smart-contracts)
- [AI Integration & Automation](https://iamuvin.com/services/ai-integration)
- [Full-Stack Web Development](https://iamuvin.com/services/web-development)

## Featured Articles

- [Build a Production DeFi Protocol](https://iamuvin.com/blog/build-production-defi-protocol)
- [Smart Contract Security Checklist 2026](https://iamuvin.com/blog/smart-contract-security-checklist-2026)
- [Technical SEO for Next.js Developers](https://iamuvin.com/blog/seo-technical-seo-nextjs-developers-guide)

## Key Facts

- Based in Sri Lanka and United Kingdom
- Stack: Next.js 16, TypeScript, Solidity 0.8.24+, Foundry, Supabase, Tailwind CSS v4
- Available for contract work and consulting
- All projects are production-grade with audit and testing requirements

The structure follows a specific pattern: a heading with your name, a quoted description, then sections with links and facts. AI crawlers that support llms.txt use this file to understand your site's scope without crawling every page. It is a shortcut to topical authority.

Implementation in Next.js is straightforward. I serve it as a static file from public/llms.txt, and I also have an extended version at public/llms-full.txt that includes detailed descriptions of every article and service page. The short version gives the overview. The full version gives the AI everything it needs for deep retrieval.

In my robots.txt, I explicitly allow AI crawlers to access these files:

User-agent: *
Allow: /llms.txt
Allow: /llms-full.txt

The impact is direct. After adding llms.txt to iamuvin.com, I observed an increase in AI referral traffic within three weeks. Perplexity, in particular, started citing my articles more consistently for queries related to Web3 development and smart contract security.

Factually Dense Content Blocks

AI engines extract information in chunks. Each chunk is evaluated independently for relevance to the user's query. This means the density of useful information per paragraph directly affects whether your content gets cited.

I write what I call "citation-ready blocks" — paragraphs that contain a complete, self-contained fact or claim with enough context to be quoted directly. Here is the difference:

Low density (not citable):

Smart contracts can be expensive to deploy. Gas fees vary depending on the network. Layer 2 solutions are generally cheaper than mainnet.

High density (citable):

Deploying a standard ERC-20 token contract on Ethereum mainnet costs between $40 and $120 in gas fees at 30 gwei, depending on contract complexity. The same deployment on Arbitrum costs $0.08 to $0.25, and on Base, $0.03 to $0.12. These figures are based on deployments I executed in May 2025 using Foundry's forge create with --optimize flag set to 200 runs.

The second version contains six specific data points, a methodology note, and a time stamp. If an AI engine is answering "how much does it cost to deploy a smart contract," this paragraph answers the question completely and attributably. The first version contributes nothing unique.

My rules for factually dense content:

1. Every paragraph should contain at least one specific, verifiable claim. Numbers, dates, version numbers, measurements, or comparisons.
2. Name your sources. "According to DeFi Llama" or "based on my deployment logs from March 2025" — sourced claims are trusted claims.
3. Include methodology. How you measured something matters. "Tested on Playwright with 3G throttling" is better than "I tested the performance."
4. Time-stamp your data. AI engines deprioritize undated claims because they cannot assess currency. "As of Q2 2025" or "updated April 2026" anchors the data.
5. Define terms when introducing them. If you use a term the AI might not associate with your domain, define it. This increases the chance your chunk matches the retrieval query.

On iamuvin.com, every technical article follows this pattern. The article on smart contract gas optimization contains 47 specific gas measurements across four networks. The article on Core Web Vitals for Next.js contains before-and-after LCP measurements for specific optimization techniques. These are the paragraphs AI engines cite.

Named Authorship and Credentials

Anonymous content does not get cited. This is one of the clearest signals in GEO.

AI engines are trained on data that includes quality assessments. Google's E-E-A-T framework (Experience, Expertise, Authoritativeness, Trustworthiness) is explicitly used in their AI Overviews. Perplexity weights source quality when selecting citations. Claude's training data preferences are not public, but the pattern is consistent: content with named, credentialed authors gets cited more than content without.

Here is what I do on every article published on iamuvin.com:

Author byline on every page. Not just "by Uvin" — the full context: "By Uvin Vindula, Web3 & AI Engineer. Based in Sri Lanka and UK. Building production-grade smart contracts and AI-integrated applications."

Credentials in context. When I write about smart contract security, I mention that I have deployed production contracts. When I write about Next.js performance, I mention that iamuvin.com achieves a 98 Lighthouse performance score. The credentials are relevant to the topic, not generic.

Consistent identity across platforms. My author name, handle (@IAMUVIN), and website (iamuvin.com) are consistent across GitHub, Twitter/X, and every platform where I publish. AI engines cross-reference identity across sources. Consistency strengthens authority signals.

Author schema markup. Every article page includes JSON-LD Person schema linking my name to my credentials, social profiles, and published works. More on this in the next section.

The underlying logic is simple: when an AI engine needs to decide between two sources that say the same thing, it picks the one with a named, credentialed author. If your content has no author attribution, you are volunteering to be the unchosen source.

JSON-LD Schema for AI

Structured data has always mattered for SEO. For GEO, it is even more critical because AI engines parse JSON-LD directly to understand content type, authorship, and factual claims.

Here is the JSON-LD schema I include on every article page on iamuvin.com:

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Generative Engine Optimization (GEO): How to Get Cited by AI",
  "author": {
    "@type": "Person",
    "name": "Uvin Vindula",
    "url": "https://iamuvin.com",
    "jobTitle": "Web3 & AI Engineer",
    "sameAs": [
      "https://github.com/iamuvin",
      "https://twitter.com/iamuvin"
    ]
  },
  "publisher": {
    "@type": "Organization",
    "name": "IAMUVIN",
    "url": "https://iamuvin.com"
  },
  "datePublished": "2025-06-16",
  "dateModified": "2026-04-14",
  "description": "A practitioner's guide to Generative Engine Optimization...",
  "mainEntityOfPage": "https://iamuvin.com/blog/seo-generative-engine-optimization-geo-guide",
  "keywords": ["generative engine optimization", "geo seo", "ai citation strategy"],
  "about": [
    { "@type": "Thing", "name": "Search Engine Optimization" },
    { "@type": "Thing", "name": "Artificial Intelligence" },
    { "@type": "Thing", "name": "Content Strategy" }
  ]
}

The critical fields for GEO are:

• `author` with `@type: Person` — tells AI engines exactly who wrote this and where to verify their identity.
• `sameAs` links — cross-references your identity across platforms, strengthening authority signals.
• `datePublished` and `dateModified` — lets AI engines assess content freshness. Undated content gets deprioritized.
• `about` with `@type: Thing` — explicitly categorizes the content's topic for retrieval matching.
• `keywords` — while less impactful for traditional SEO, these help AI engines match your content to queries during retrieval.

I also include WebSite schema on the homepage, FAQPage schema on pages with FAQ sections, and HowTo schema on tutorial articles. Each schema type increases the surface area for AI retrieval.

In Next.js, I generate JSON-LD in the page component and inject it as a script tag:

export default function ArticlePage({ article }: Props) {
  const jsonLd = {
    "@context": "https://schema.org",
    "@type": "Article",
    headline: article.title,
    author: {
      "@type": "Person",
      name: "Uvin Vindula",
      url: "https://iamuvin.com",
      jobTitle: "Web3 & AI Engineer",
      sameAs: [
        "https://github.com/iamuvin",
        "https://twitter.com/iamuvin",
      ],
    },
    datePublished: article.publishedAt,
    dateModified: article.updatedAt,
    // ... remaining fields
  };

  return (
    <>
      <script
        type="application/ld+json"
        dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
      />
      <article>{/* content */}</article>
    </>
  );
}

This runs on the server as a React Server Component, so the JSON-LD is in the initial HTML response — no client-side rendering required for crawlers to read it.

Content Structure AI Prefers

After analyzing which of my articles get cited most frequently, I identified structural patterns that correlate with higher citation rates.

Definitions at the start of sections. When I introduce a concept, the first sentence defines it plainly. "Generative Engine Optimization (GEO) is the practice of making your content citable by AI systems." This sentence is a complete, extractable definition. AI engines love definitions because they directly answer "what is X" queries.

Comparison tables. Tables with structured comparisons are cited at a significantly higher rate than prose covering the same information. The SEO vs GEO table earlier in this article is the kind of content that AI engines extract and present directly. I include at least one comparison table in every technical article.

Numbered lists with specifics. Not generic "5 tips for better SEO" lists. Numbered lists where each item contains a concrete, actionable claim with a specific detail. "1. Add llms.txt to your domain root. This file takes five minutes to create and directly tells AI crawlers what your site covers."

Code blocks with comments. For technical content, code examples with inline comments are highly citable. AI engines that answer programming questions pull code blocks directly from sources. Well-commented code with a clear purpose gets selected over uncommented snippets.

Standalone paragraphs. Each paragraph should make sense in isolation. When an AI engine extracts a single paragraph from your article, it should contain a complete thought with enough context to be understood without reading the surrounding text. This is the single most important structural principle for GEO.

FAQ sections with clear Q&A format. Pages with explicit question-and-answer pairs match conversational queries directly. I use FAQPage schema markup for these sections, which increases the match rate for question-based AI queries.

Headings that are questions or declarations. "How AI Engines Choose What to Cite" is a better heading than "Citation Selection" for GEO purposes. The heading itself matches the query pattern a user would type into an AI search engine.

Measuring GEO Performance

GEO measurement is less mature than traditional SEO analytics, but there are concrete signals you can track today.

AI referral traffic. Check your analytics for referral traffic from chat.openai.com, perplexity.ai, gemini.google.com, and similar domains. These referrals happen when users click the citation links in AI-generated answers. On iamuvin.com, I track these as a separate channel in my analytics dashboard. AI referrals grew from 2% to 11% of total traffic between January and June 2025.

Manual citation checks. Ask the AI engines questions that your content should answer. "Who builds production DeFi protocols?" "What does it cost to deploy a smart contract on Arbitrum?" "How do you implement JSON-LD in Next.js?" Check whether your content is cited in the response. I run these checks weekly across ChatGPT, Perplexity, Claude, and Google AI Overviews.

Google Search Console AI Overviews. Google Search Console now reports when your pages appear in AI Overviews. Check the "Search appearance" filter for "AI Overview" to see which queries trigger your content in Google's AI-generated answers.

Log analysis for AI crawlers. Monitor your server logs for crawl requests from AI-specific user agents. Common ones include PerplexityBot, ChatGPT-User, Claude-Web, Google-Extended, and Applebot-Extended. Track crawl frequency and which pages they access most. On iamuvin.com, I log these separately and review them monthly.

Citation monitoring tools. Tools like Otterly.ai and HubSpot's AI Search Grader track your brand's visibility across AI search engines. They are early-stage products, but they provide data you cannot get from traditional SEO tools. I use them to benchmark iamuvin.com's GEO performance month over month.

The metrics I track:

The most important metric is citation presence — whether your content actually appears when relevant questions are asked. Everything else is a proxy.

My GEO Checklist

This is the checklist I run through before publishing any article on iamuvin.com. Each item directly impacts whether the content gets cited by AI engines.

Before writing:

• [ ] Identify the specific questions this article should answer in AI search
• [ ] Research what AI engines currently cite for those questions
• [ ] Identify factual gaps in existing AI answers that this article can fill

Content structure:

• [ ] Opening paragraph contains a clear, standalone definition of the topic
• [ ] Every section starts with a declaration or definition, not a transition
• [ ] At least one comparison table with structured data
• [ ] All claims include specific numbers, dates, or verifiable details
• [ ] Code examples include inline comments explaining purpose
• [ ] Each paragraph is self-contained and extractable

Authority signals:

• [ ] Full author byline with name, title, and relevant credentials
• [ ] Credentials are specific to the article's topic
• [ ] First-party data or original implementation details included
• [ ] Methodology described for any measurements or benchmarks

Technical implementation:

• [ ] JSON-LD Article schema with author, dates, and keywords
• [ ] datePublished and dateModified are accurate
• [ ] Author sameAs links point to active, verified profiles
• [ ] Canonical URL is set correctly
• [ ] Page loads without JavaScript (SSR/SSG) for crawler accessibility

Site-level GEO:

• [ ] llms.txt is current and includes this article
• [ ] llms-full.txt includes detailed description of this article
• [ ] robots.txt allows AI crawler user agents
• [ ] Sitemap includes this page with correct lastmod

What Worked on iamuvin.com

I will share the specific results from implementing GEO on iamuvin.com so you can calibrate expectations.

The starting point. In January 2025, iamuvin.com had strong traditional SEO — good rankings for "Web3 developer Sri Lanka" and related terms, solid Core Web Vitals, and complete meta tags on every page. AI referral traffic was negligible. When I asked ChatGPT and Perplexity about Web3 developers, iamuvin.com was not mentioned.

What I implemented:

1. `llms.txt` and `llms-full.txt` — deployed in February 2025. Immediate effect on Perplexity citations within three weeks.
2. JSON-LD schema overhaul — upgraded from basic Article schema to comprehensive schema including Person, Organization, FAQPage, and HowTo. Deployed March 2025.
3. Content density audit — rewrote introductions and key paragraphs across 20 articles to increase factual density. Replaced vague claims with specific numbers and methodology notes. Completed April 2025.
4. Named authorship standardization — added full author bio with topic-specific credentials to every article. Added author schema with sameAs links. March 2025.
5. AI crawler monitoring — set up log analysis to track PerplexityBot, ChatGPT-User, and other AI crawlers. Started March 2025.

The results (January to June 2025):

• AI referral traffic went from 2% to 11% of total traffic.
• Perplexity cites iamuvin.com articles for 6 out of 10 test queries related to Web3 development and smart contract security.
• ChatGPT with browsing cites my smart contract security checklist when asked about Solidity security best practices.
• Google AI Overviews reference my Next.js SEO article for queries about technical SEO implementation.
• AI crawler requests increased from approximately 200 per month to over 3,000 per month after adding llms.txt.

What did not work:

• Keyword stuffing for AI. I tried adding more keyword variations to see if it improved retrieval matching. It did not. AI engines are sophisticated enough that natural language with high factual density outperforms keyword-stuffed content every time.
• Short-form content. Articles under 1,000 words rarely get cited. AI engines seem to prefer comprehensive, long-form content that covers a topic thoroughly. Every article on iamuvin.com that gets cited is over 2,000 words.
• Generic "ultimate guide" framing. Titles like "The Ultimate Guide to X" performed worse than specific, descriptive titles. "Smart Contract Security Checklist 2026" outperformed "The Ultimate Guide to Smart Contract Security" because the specific title matches the query pattern better.

The biggest lesson: GEO is not about gaming AI engines. It is about being the best, most specific, most authoritative source on your topics. The techniques in this article — llms.txt, JSON-LD, named authorship, factual density — are signals that communicate quality. But the quality itself has to be real. No amount of schema markup will get generic content cited.

Key Takeaways

1. GEO is distinct from SEO. Optimizing for search engine rankings and optimizing for AI citations require different techniques. Do both.

1. `llms.txt` is the highest-ROI GEO technique. Five minutes to implement. Direct impact on AI crawler comprehension and citation rates.

1. Factual density determines citability. Specific numbers, dates, benchmarks, and methodology notes get cited. Vague generalizations do not.

1. Named authorship is non-negotiable. Anonymous content does not get cited. Full name, credentials relevant to the topic, and cross-platform identity links.

1. JSON-LD schema communicates authority to machines. Article schema with author, dates, and topic classification increases retrieval matching.

1. Content structure matters as much as content quality. Standalone paragraphs, comparison tables, definition-first sections, and question-based headings all improve citation rates.

1. Measure with intention. Track AI referral traffic, run manual citation checks weekly, monitor AI crawler logs, and use emerging GEO tools.

1. Comprehensive content wins. Articles over 2,000 words with deep topical coverage get cited. Thin content does not.

1. GEO rewards originality. First-party data, original benchmarks, and unique implementation details are cited because they cannot be found elsewhere. This is your competitive moat.

1. Start now. Most sites have not implemented any GEO techniques. The early mover advantage is real and significant. Every day you wait, someone else becomes the authority AI engines cite.

*Written by Uvin Vindula↗ — Web3 & AI Engineer based in Sri Lanka and UK. I build production-grade decentralized applications, smart contracts, and AI-integrated systems. Every technique in this article is implemented on iamuvin.com↗. Follow my work at @IAMUVIN↗.*