Write the Wiki for the LLM: Documentation's New Reader
Here is a shift that has already happened, whether or not your documentation noticed: a large and growing share of the readers of everything you write are no longer human. They're language models — reading your docs to answer a question, your README to use your library, your marketing page to tell someone what you do. Andrej Karpathy has been making this point for a while, and it lands harder every month: the primary reader of a lot of your writing is now an LLM, and you are probably still writing for a human.
This is a look at that idea — sometimes called writing an "LLM wiki," or knowledge for machines — and what it actually changes about how you produce docs. It's not a call to stop writing for people. It's the recognition that you now have a second, very different reader, and that reader has been quietly ignored.
The two readers read nothing alike
A human reading your docs skims. They jump to the code block, infer meaning from a screenshot, tolerate a nav bar and a cookie banner and three paragraphs of positioning, and click around until they find the part they need. Human docs are built around all of that: visual hierarchy, interactivity, and the reader's willingness to fill gaps.
An LLM reads none of it that way. It ingests text mostly linearly. It can't click your "see also." It can't see the screenshot that contained the actual answer. It chokes on the chrome — the navigation, the boilerplate, the styling markup — and spends context on all of it. And critically, it will not tell you it got confused; it will confidently produce an answer from whatever it managed to parse, gaps included.
So the same page that works beautifully for a person can be nearly useless to a model: the key fact was in an image, the steps were split across five clicked pages, and half the tokens were spent on a header that repeats on every route.
What "writing for the LLM" actually means
Karpathy's framing is useful because it's concrete once you take the reader seriously. Writing for the model reader means:
- Plain, linear, self-contained text. The answer should be in the words, not in a diagram or a video or three hops away. If a model reading top to bottom can't extract it, neither can the model your users are asking.
- Structure a machine can parse. Clear headings, explicit lists, real markdown — not visual layout that only means something rendered.
- Say the thing, drop the performance. The positioning fluff, the repeated chrome, the SEO padding — all of it is pure cost to a model and adds nothing to the answer. Density of fact per token is the metric.
- Completeness over cleverness. A human forgives a doc that assumes context. A model doesn't have your context; it has what's on the page.
The mental test is simple: paste the raw text of your page into a model, ask it the question your user would ask, and see if it can answer from that alone. If it can't, your human-facing polish is hiding the substance from your fastest-growing audience.
The LLM wiki, made concrete
The clearest instantiation of this idea already exists and is easy to adopt.
llms.txt — a convention proposed by Jeremy Howard — is a plain-markdown file at
the root of your site that gives models a clean, curated map of what you are and
where the real information lives, free of the HTML and navigation they'd
otherwise wade through. It's a wiki entry for your site, written for the machine.
The broader "LLM wiki" idea generalizes that: a body of knowledge maintained specifically for model consumption — unambiguous, structured, complete, and kept current. Not a copy of your human docs with the styling stripped, but knowledge authored with the model as the intended reader. Where Wikipedia organized the world's knowledge for people to read, the LLM wiki organizes it for models to reason over.
This is the same move as the search era, one layer up. For two decades, teams learned to write for Google's crawler — that was SEO. The reader was an index. Now the reader is a model that will synthesize an answer and cite whoever it understood best. Writing for the LLM is the AEO successor to writing for search: the audience changed from an index to a reasoner, and the craft changed with it.
Why it's worth doing now
The payoff is direct and it compounds. When a user asks ChatGPT, Claude, or an AI search engine about your problem space, the answer is assembled from whatever sources the model could parse and trust. Documentation written for the model is documentation the model can actually use — which means you get represented accurately in the answer, and cited, instead of paraphrased wrong or skipped for a competitor whose page was cleaner to read.
There's an internal payoff too. The same properties that make knowledge good for an external model make it good for your own agents. An agent that reads your internal docs to do its job has exactly the LLM reader's constraints — linear, context-limited, unable to click. Knowledge authored for machines is knowledge your own automation can act on. The wiki you write for the world's models is the wiki your own agents read too.
How we approach it at CatalEx
We try to practice this, including on the blog you're reading. It ships an
llms.txt that describes what CatalEx is in plain markdown; a robots.txt that
explicitly welcomes AI crawlers rather than blocking them; structured data so a
model can attribute a post correctly; and posts written to be self-contained —
the argument is in the prose, not locked in an image. The goal is that when a
model reads any of it, it comes away with an accurate, citable understanding, not
a pile of chrome it has to guess through.
None of this is exotic. It's the old discipline of writing clearly, with one update to the audience: the most frequent, most literal, least forgiving reader of what you publish is now a model. Karpathy's point is really just that — take that reader seriously. Write the wiki for the LLM, and you serve the humans who ask it questions at the same time.
Written by CatalEx Engineering. We build the AI operating layer for AI-native companies — one platform to build, deploy, and run AI agents in production. More at catalex.co.