GEO: How AI Answer Engines Decide Who to Cite

AI answer engines don't rank pages, they quote passages. That single mechanical difference invalidates half of what SEO taught you. Google rewarded you for winning a position; Perplexity, ChatGPT search, and Claude's web tools reward you for writing a paragraph that survives being ripped out of your page and pasted into someone else's answer. GEO, Generative Engine Optimization, is the discipline of writing paragraphs that survive that surgery.

How an answer engine actually reads your page

The pipeline is roughly the same across engines. A crawler or on-demand fetcher pulls your HTML. The page gets stripped to text, split into chunks (usually a few hundred tokens, often along heading boundaries), and embedded. When a user asks a question, the engine retrieves the top-scoring chunks across the web, stuffs them into a context window, and asks a model to synthesize an answer with citations.

Notice what's absent: PageRank, dwell time, your beautiful hero section. The unit of competition is the chunk. Your page doesn't get cited. A 200-word slice of it does, and that slice competes against slices from every other page on the topic.

This has a brutal corollary. If the fact a user needs is spread across three paragraphs, two pronouns, and a screenshot, no single chunk contains the answer, and you lose to a mediocre page that put it in one sentence.

What we see in the installs.me logs

installs.me gets a visible slice of traffic from AI browsers and answer engines. The fetchers announce themselves in the user agent: GPTBot, PerplexityBot, ClaudeBot, plus on-demand fetches that fire seconds after a user asks something. The human referrals that follow show up from perplexity.ai and chatgpt.com.

The pattern in which pages get fetched and which get cited is consistent enough to be a lesson:

• The pages that get quoted are the ones containing exact, copy-pasteable commands. Our two-line install block (/plugin marketplace add, then /plugin install) gets lifted verbatim into answers about installing Claude Code plugins. Prose descriptions of the same procedure, on the same site, do not.
• On-demand fetchers grab one page and leave. They do not crawl your nav. If the answer isn't on the URL they fetched, you're invisible for that query.
• Pages whose content requires JavaScript to render get fetched and discarded. Most of these fetchers read the initial HTML response. If your docs hydrate client-side, the bot sees a spinner.

None of this is exotic. It's the retrieval pipeline behaving exactly as described above.

The anatomy of a quotable passage

Four properties, in order of impact.

Self-contained facts. Every paragraph should survive with zero surrounding context. "It uses a manifest file" is dead on arrival; which "it"? Write "A Claude Code plugin marketplace is a marketplace.json file that lists installable plugins" and the chunk carries its own subject, its own definition, and a term someone actually searches for. Kill pronoun chains. Restate the noun. It reads slightly redundant to humans and perfectly to a retriever.

Precise commands and file shapes. An engine answering "how do I install a Claude Code plugin" will cite the page containing this:

/plugin marketplace add https://installs.me/lautaro
/plugin install lautaro@lautaro-installs

over the page containing "simply add the marketplace and install the plugin." Exact strings win twice: they match the query embedding tightly, and the synthesizing model prefers to quote something it can't garble. Same logic for file structure. "A skill is a SKILL.md with YAML frontmatter (name, description) plus an optional references/ directory" is a sentence engines can quote; "skills are configured via metadata" is not.

Headings that are questions, or answers to them. Chunkers split on headings, and retrieval scores the heading with the chunk. ## Why relative HTTP paths fail in marketplace.json will match a frustrated user's query nearly verbatim. ## Troubleshooting matches nothing. Every H2 on your page is a search query you're bidding on. Bid on specific ones.

One claim per sentence, early. Models synthesizing under token pressure quote your first sentence and skim the rest. Front-load. The inverted pyramid, dead in blogging for a decade, is the native format of GEO.

The failure modes

The mirror image is just as instructive. Content that never gets cited:

• Hedged content. "It depends on your use case" gives the model nothing to assert. Engines cite sources that commit. Opinions with reasons get quoted; surveys of considerations don't.
• Facts trapped in images. Screenshots of terminal output are invisible to a text pipeline. If the command matters, it goes in a fenced code block.
• Marketing interleaved with mechanism. A paragraph that's 30% adjectives scores worse against a technical query than a plain one, and the model has to work to extract the fact. It usually picks the source where it doesn't have to.
• Splitting one answer across many pages. Good for pageviews, fatal for chunks. The engine fetches one URL. Put the whole answer on it.

GEO is just writing for a very literal reader

Here's the honest summary: every GEO tactic above is also a readability tactic. Self-contained paragraphs, specific headings, exact commands, claims up front. The retrieval pipeline is a reader with no patience, no memory of your other pages, and no ability to infer what "it" refers to. Writing for that reader makes your docs better for humans too, especially the human who arrived from an AI answer, already primed with your quoted paragraph, checking whether the rest of the page keeps that promise.

The engines will keep changing. The chunk sizes, the crawlers, the citation formats, all of it. The property that won't change is that a machine has to select a slice of your writing and stake its answer on it. Write slices worth staking an answer on.

Install a person

installs.me turns your files, calendar and calls into a Claude Code plugin that thinks like you. Anyone installs it with two commands:

/plugin marketplace add https://installs.me/lautaro
/plugin install lautaro@lautaro-installs