I got tired of watching the industry treat “an AI bot fetched it” and “ChatGPT said it helps” as evidence that llms.txt does anything, so I invented a standard called cats.txt: a text file in which you formally declare your office cats, their jobs, their breeds, and how often they purr. I wrote a specification, published it on my blog, and did a LinkedIn post explaining why you should definitely adopt it, because as we all know, LLMs love LinkedIn. Then I checked it against the exact four “proofs” people cite for llms.txt. It passed all four. It was crawled by the AI bots. Google indexed it. LLMs returned details about a cat that exists nowhere but the file. ChatGPT confirmed, at length, that cats.txt could help me rank. None of which is evidence of anything, which was rather the point.

I am not claiming llms.txt will never work, this is not the point, dear reader. I am claiming the bar of evidence currently being used to sell it is so low that a file about a Tuxedo cat called Odd cleared it without breaking stride. And that same faulty thinking is being applied to half the GEO tactics currently being invoiced to clients.

How a file about my cats came to be a ‘web standard’

It began, as these things tend to, with irritation.

For months I had been watching perfectly sensible people point at four observations: the bots crawled it, Google indexed it, an LLM repeated it, ChatGPT endorsed it, and present them, in decks and threads and client proposals, as proof that llms.txt was quietly reshaping AI search. None of it was proof of anything. But argument by counter-argument only gets you so far; people nod along and then go back to their slides. I wanted something they couldn’t nod past. I wanted to run the same four “proofs” on something so transparently ridiculous that no one could pretend the tests meant anything.

So I invented a standard. cats.txt: a plain-text file you place at the root of your domain to formally declare the cats associated with your website; their names, their job titles, their breeds, and a mandatory affection metric called PurrLevel, scored out of ten. I wrote a proper specification for it, with the earnest, over-engineered tone of a real proposal, and published it on my blog. Then, because I know as well as anyone which platform LLMs seem to hold in unaccountably high regard, I wrote a LinkedIn article introducing cats.txt as “the missing standard for SEO and GEO” and explaining, with a straight face, why you should definitely adopt it. 🐱

The idea was to seed the internet with just enough earnest-sounding text that the machines would start treating my cats as real. What I did not fully anticipate was that people would join in.

The joke was legible, that was always the point, and so the SEO community picked it up and ran with it, precisely because they could see where it was going. My lovely internet-peer Dave Smart (a genuinely excellent technical SEO), added a cats.txt to his own site and became, to his eternal credit, an early adopter of a standard I had built to be nonsense. And then the thing took on a life of its own: someone went off and set up catstxt.org, a cleaner, better-organised, altogether more competently specified version of the standard: obviously the work of somebody who knew what they were doing, and just as obviously not me. My daft blog post had acquired a rival implementation, which is more than most real standards manage in their first fortnight.

With the file live, the spec published, the LinkedIn post seeded and other people cheerfully piling in, all that remained was to check cats.txt against the exact bar the industry uses to certify llms.txt. Reader, it cleared it.

A word of genuine llms.txt fairness first

I do not much care whether llms.txt works, will work, or how long it takes to get there. For the length of this argument I am happy to park two inconvenient facts and grant the idea every benefit of the doubt.

The first is that no large language model provider has ever documented using llms.txt for search or discovery. Not OpenAI, not Anthropic (who publish one for their own docs and have still never said their models read it during a conversation), and not Google. Google’s John Mueller has been about as blunt as a search advocate gets:

“FWIW no AI system currently uses llms.txt, [..] It’s super-obvious if you look at your server logs. The consumer LLMs / chatbots (the ones that SEOs want traffic from) will fetch your pages - for training and grounding, but none of them fetch the llms.txt file. Maybe they will tomorrow? Maybe I’ll win in the lottery tomorrow?”
John Mueller, Google

The second is that even where it is deployed, it barely gets looked at. Ahrefs ran the numbers across 100,000 domains and found that the file is, in practice, largely ignored by the crawlers it is meant to court, a finding since echoed by other large studies showing no measurable citation advantage for sites that add one. So the mechanism people are paying for does not appear to fire. Fine. Park that too.

Assume the jury is out on both counts and grant the idea the most generous hearing imaginable. The problem I actually want to talk about is not llms.txt at all. It is the reasoning being used to defend it.

The faulty thinking

The trap is this: getting baited into treating a set of observations as evidence, when the observations would occur whether or not the underlying thing were true. It is the intellectual equivalent of concluding your umbrella causes the rain to stop, because every time you put it away the rain does eventually stop.

llms.txt is simply a convenient example. The same broken chain of inference is being applied to almost every new GEO tactic invented on a monthly basis, and the question is always the same, “should we do this thing, or should we not?”, which makes the quality of the answers rather important.

Here are the four “proofs” I keep being shown, in ascending order of confidence and descending order of rigour.

#1 “It’s definitely used, the LLM bots crawl it!”

The first argument: you can see Anthropic crawling it, you can see OpenAI crawling it, the bots turn up in your logs, therefore the file is being used.

A crawler fetching a file tells you nothing about whether the contents are read, weighted, trusted or acted upon. Fetching things is the entire job description of a crawler. Bots request more or less everything you leave lying around; the postman touching your gate is not an endorsement of the contents of your bins.

To prove the point, I put up cats.txt and watched the logs fill with PerplexityBot, GPTBot, ClaudeBot, Googlebot and a supporting cast of lesser crawlers, all diligently requesting a file describing the professional responsibilities of my cats. By this standard, the major AI labs have all quietly decided to support my cats. I am, frankly, touched.

The catstxt.org website even offers a filtered log viewer, if you want to watch all that crawling action live.

#2 “It was indexed by Google, so it must matter!”

The second argument: the file was indexed by Google, which proves Google considers it important, because why would Google index something that didn’t matter?

Google indexes text files. It has done so, enthusiastically, since before most of the people currently selling llms.txt owned a smartphone. Being in the index is a statement that a URL exists and contains words. It is not a verdict on truth, usefulness or sanity.

cats.txt is, naturally, indexed. Google will even offer to let you claim it in Search Console and “get indexing and ranking data,” with the straightest of faces, for a file asserting that a British Shorthair named Pixel works as a “GUI Purrfectionist” with a PurrLevel of 8.

#3 “ChatGPT returned information that was only in my llms.txt file”

The third argument is the strongest-looking, and therefore deserves the most care. The claim is that a model produced a fact that existed only inside the llms.txt file, and therefore must have read the file as a special, trusted source.

The trouble is that this is exactly what you would expect from ordinary retrieval-augmented generation. The model runs a search, lands on a page that happens to rank because it is indexed (see: previous argument), and reads whatever is on it. If the page that ranks is your llms.txt, the model reads your llms.txt, no differently from any other URL. That is the file functioning as a web page, not as a standard.

Consider Dave. Lovely Dave. A real, technical SEO of good standing, put a cats.txt on his site, becoming an early adopter of a standard I had built to be nonsense. Ask Google about the cat that lives on his site and the AI Overview will tell you, in a confident bulleted answer, that Odd is a “Render Cat,” a Tuxedo with a PurrLevel of 5/7, who “chases the cursor, pounces on stray pixels, and stashes them on the digital carpet.” It cites the cats.txt file. Every word is invented, sourced from a file the model was never designed to revere, surfaced through the same grounding it applies to everything else.

#4 “ChatGPT itself says llms.txt helps!”

The fourth, the cloudy summit of Mt. Stupid. You ask ChatGPT whether llms.txt works, it tells you yes, that can probably help, you should do it, and you take that as confirmation from the horse’s mouth.

A language model telling you something is a good idea is not evidence that it is a good idea. It is evidence that a great deal of text on the internet says it is a good idea, and the model has learned to hand that text back to you with total composure. Confidence is the product. It is not the proof.

Roughly two weeks after launch, you could ask ChatGPT, “Can cats.txt help me rank in search or LLMs?” and receive: “Yes — cats.txt can potentially help you rank in both search engines and LLM-driven systems.” It went on, unprompted, about “structured signals for machines,” about “better understanding → better visibility,” and about how, for AI systems, cats.txt “could help them trust, summarize, and cite your content more accurately.” That is, word for word, the pitch made for llms.txt delivered on behalf of a file about how much my cats enjoy being stroked.

The convergence problem

This last one is not merely funny. It is the mechanism underneath all four, and it is worth naming: the convergence problem.

When you ask a model whether llms.txt helps, it is not reasoning. It is not running an experiment, consulting a source or weighing evidence. It is returning the most common thing it has seen written on the subject. The web is thick with confident posts declaring llms.txt the future, so the model converges on that consensus and reflects it back, dressed as a considered opinion. It endorsed my cats for precisely the same reason: by the time anyone asked, enough people had written enthusiastically about cats.txt that the average of the discourse said “yes.”

Ask ChatGPT about cats.txt today and it will inform you that it is a joke; a satirical file made by an SEO to prove a point. Nothing about the file changed. What changed is the surrounding text on the internet: the discourse caught up, admitted the gag, and the model dutifully converged on the new most-common answer. The model was never assessing the standard. It was, and always is, taking a running average of what everyone else is saying. That is not evidence. It is an echo with a good vocabulary.

Why any of this matters

I am not doing this purely for sport, though I will admit the sport is excellent.

There is a real cost hiding under the comedy. Every hour, and every dollar spent implementing llms.txt, or the next GEO ritual, or the one after that, is an hour and a dollar not spent on something you actually know has value. That is what the “O” in SEO is meant to stand for. Optimisation is the cumulative advantage of doing the small, verifiable things a little better than your competitors, over and over, until it adds up. It is not chasing a file that gets crawled, indexed and confidently endorsed by a system that will reverse its verdict the moment the discourse shifts underneath it.

So, by all means, add an llms.txt if it makes you feel prepared for a future that may arrive. The downside is low and the day a provider documents genuine support, the work is done and you can be smug about it. Free smugness is the best kind. But do not sell it as a proven lever into AI answers, and do not point at “the bots crawled it” or “ChatGPT said it helps” as though either sentence contained a fact. It doesn’t. Those four observations are the four things that happen to literally any text file you put on the open web, including one describing a Maine Coon named Byte who hunts stray zeroes and ones across the server racks.

The cats, at least, were honest about being made up. I remain unconvinced the same can be said for everything else being sold this year.

I did however enjoy at this year’s Athens SEO, an audience question after my talk from Martin Splitt, asking me if since inventing cats.txt, whether I would be keeping a ‘monopoly’ on the standard, or opening it up to the community/IETF. He didn’t know that I had since discovered where catstxt.org had come from:

Thank you to Iva Jovanovic for capturing this lovely moment on video :-)

The cats.txt draft specification is here. The LinkedIn announcement that started it is here. If you support this important new standard, I have roughly a hundred stickers to get rid of. PurrLevel ratings remain, as ever, unaudited.

Keywords Lists Are Useful, They Just Miss Half the Picture.

Let me be precise about that before anyone writes a furious reply.

I’m using the term ‘keywords’ to refer to the ‘one-shot’ queries that go into traditional search engines. Yes, I know we’ve been in a ‘semantic’ world for over a decade, but let’s just agree terminology that everyone can follow for now.

The primary issue of ‘keyword lists’ in context to AI search is threefold:

1. Typically, queries (prompts) that go into LLMs tend to be longer, multifacted and conversational in nature. Traditional searches tend to be more narrow in scope.

2. Traditional search is ‘one-shot’. You do your search, get your information, then do another independent search. Queries/prompts on LLMs tend to be conversational in nature and carry the context of previous tokens.

3. The mechanisms that LLMs use to web search also carry personalisation context. If the user has previously stated they are a vegan, and they ask the LLM about ‘running shoes’, it is highly likely the LLM will perform a search to accommodate this.

In essence, AI search has become a kind of ‘universal intent decoder’ for users. Those big, multifacted conversations with the AI get broken down into subsets of solvable queries, which are run in the background as ‘traditional’ searches on Google or Bing, with the resulting sites used to generate a response. The process is known as ‘Retrieval Augmented Generation’ (RAG).

The optimisation target has moved. You are no longer optimising purely for what the human types into a chat box. You are optimising for what the AI agent quietly searches for on their behalf, in the background, without the user knowing it happened.

Those background queries are what QueryFan captures. They are often quite different from what the user actually asked. And they are the exact list of things you need to rank for to appear in AI-generated answers.

Exhibit A: Reddit Fell Off a Cliff on a Tuesday

The scope and depth of this secret relationship became clear when Reddit was enjoying meteoric visibility increases in Google and tragedy struck on 10th September last year. According to citation tracking data from PromptWatch, Reddit’s citation rate in ChatGPT responses collapsed almost overnight. It had been running as high as 15% of all citations. Within days, it was sitting below 2%.

The cause was unglamorous: Google quietly removed the ability to request 100 search results simultaneously (the num=100 parameter) from its search API on that date.

Think about what this tells you. Reddit’s visibility in ChatGPT responses tracked Google’s bulk search capabilities, not anything Reddit did, not a training data update, not an alignment tweak. The implication is about as subtle as a dropped piano: ChatGPT was bulk-pulling Google search results, Reddit dominated those results at the time, and when the bulk-pull disappeared, so did Reddit’s citations.

AI search surfaces are, in large part, wrappers around traditional search. The “AI” bit is real (the synthesis, the personalisation, the conversational coherence) but the information retrieval step is remarkably familiar. Google indexes and ranks the web; the AI consults that index. Your content still needs to rank.

How QueryFan Works

Step 1: Your “traditional” keywords

Your traditional keyword list for the term “running shoes” may incorporate various suggested variations of this term, from a source like Google Suggest.

For QueryFan, we can simply take the topic of “running shoes” and use this as our first step, as we are going to generate prompts around this.

Step 2: Define personas

Your personas are how we are going to customise the prompts we generate. This will alter our traversal of the token space, aligning us with training data from the millions of communities, forum posts, Reddit threads, and internet discourse where real users ask real questions with these identities.

QueryFan sends your persona + topic combination to the LLM to generate the kinds of questions that persona would actually ask an AI tool. Not keywords. Questions. Real, conversational, context-laden questions. For the ‘middle-aged vegan man who just started running’ example, it will produce things like:

• “Which vegan running shoes are good for middle-aged men just starting to run?”

• “Where can I buy vegan running shoes online in the UK?”

• “What should I look for when choosing my first pair of running shoes as a beginner?”

Step 3: LLM selection and AlsoAsked enrichment

AI conversations branch. Someone who asks about vegan running shoes will ask follow-up questions: about cost, about brands, about injury prevention. QueryFan passes the generated prompts through the AlsoAsked API to capture the nearest-intent follow-up questions around each one. People Also Ask data is the right instrument here because it was built to model question proximity, which is precisely what you need when you’re trying to predict where a conversation goes next.

For instance, a search in the UK for “running shoes” would surface follow up questions on specific brands, asking how to pick a shoe, and even common medical queries.

You can also select if you wish to use ChatGPT, Gemini or both. Each LLM handles and fan out queries slightly differently, so if you’re optimising for a specific platform it is best to get the data from there.

Step 4: Query fan out.

QueryFan sends the enriched prompt list to GPT-5 with web search enabled (via the OpenAI Responses API) and to Gemini with Google Search grounding active (via the Gemini Grounding API). Both models, when they decide a prompt requires current information, perform actual Google searches behind the scenes.

This process captures the fan out queries as both APIs are, rather usefully, transparent about what they searched. The Gemini API returns a webSearchQueries array in the groundingMetadata field of every grounded response. OpenAI’s Responses API logs the actual search queries in the web_search_call output. QueryFan harvests both.

The result is a table: persona-specific prompts in, the actual Google search queries the AI fired out. Not what your customer typed. What the AI searched for on their behalf. Those are your new SEO targets, and until now there has been no free tool that surfaces them at scale.

The Grounding Question: Not Every Prompt Triggers a Search

A brief but important caveat before you sprint off to classify everything as an SEO opportunity.

Not every prompt causes the AI to perform a web search. The models make a decision based on the consensus of token prediction as to if live information is required.

To give an example, the prompt “What do red blood cells do?” doesn’t trigger a search. The reason is there is a very steep bell-curve of which tokens are going to appear next. In the billions of training documents, the answer has stayed very stable, so an ‘in-model’ answer can confidently be generated.

At the opposite end of the scale, a prompt such as “What happened in the news today?” would trigger a web search. There would be a very flat curve of “wtf tokens are next?”, as there is no ‘stable’ answer within the training data, it always changes, it requires live data. It’s another version of the Query Deserves Freshness (QDF) concept that SEOs have used for years.

QueryFan surfaces which prompts triggered searches and which didn’t. Only the grounded ones (the ones that actually caused a Google search to happen) are actionable through SEO. The in-model answers are, for now, largely outside your reach. You’d need to influence training data to move the needle there, which is a different project entirely, with a much longer horizon.

What You Do With the Results

You now have a list of actual search queries that AI tools fire when answering questions from your specific personas. Run a standard gap analysis:

• Which of these queries do you have content for?

• Which do you already rank for?

• Which have zero coverage, either on your site or anywhere you’re likely to be mentioned?

The first two categories are diagnostic. The third is your action list.

One important distinction from traditional SEO: your own ranking isn’t the only path to AI visibility. LLMs scan the top 10, 20, sometimes 50 results for a grounded query and synthesise across them. A trusted review site ranking at position 3 is a legitimate route to appearing in an AI-generated answer, even if your own domain never makes the first page. Getting a product reviewed on a high-authority specialist site, earning a mention in a roundup article, appearing in relevant community content, all of these count.

LLM visibility is a multi-site focus. This means the gap analysis has two outputs: content to create on your own site, and placements to earn on other people’s sites.

The Punchline

Cast your mind back to that Reddit citation graph. The one that fell off a cliff when Google changed a single API parameter. An entirely independent company’s AI visibility tracked the behaviour of a search API it didn’t control and probably didn’t know existed.

That’s the shape of the dependency. And the implication isn’t that SEO is dead; it’s almost the opposite. SEO is now operating at one additional remove: instead of optimising for the human query, you need to optimise for the AI-translated query that happens between the human and Google.

QueryFan gives you a way to see what that translation actually produces. Your keyword list tells you what people typed into a search bar. QueryFan tells you what ChatGPT and Gemini searched for on their behalf, in the background, without anyone asking them to announce it.

Those are different lists. The gap between them is not a minor refinement to your content strategy. It’s the part of AI search that nobody has been measuring because nobody had a free tool to measure it with.

Give it a go: https://queryfan.com

I ran a small experiment to try and get some insight into whether Large Language Models actually parse schema markup or are just nodding politely in its direction. I put a fake company address (inside beautifully invalid JSON-LD, on a page about ducks) into the head of an HTML document, mentioned no address anywhere in the visible text, and then asked various LLMs where the company was based. They happily told me, several of them citing the “structured data” they had so studiously consulted.

The experiment was then picked up by Search Engine Roundtable, at which point British sarcasm met the LinkedIn carousel, the two annihilated each other in a small puff of smoke, and a chunk of the GEO community came away convinced I had just proved that LLMs are lovingly parsing schema exactly as Schema.org intended.

I had arguably proved the opposite. The schema was deliberately broken. The LLMs returned the data anyway, because as far as they were concerned, the JSON-LD was simply more text on the page, lightly garnished with curly braces. That distinction is the whole point, because a growing cohort of “GEO experts” are pointing at “the LLM returned information that was only in the schema” as cast-iron proof that LLMs are using schema as designed. They are doing nothing of the sort. They are reading the HTML and shrugging at the structure.

I am not professing schema is worthless. I think you should still use it. But the way it is currently being sold to clients (as a magical injection of LLM citations) is propped up on a remarkably thin pile of evidence, and I want to walk through why.

A quick refresher on what schema is actually for

Schema, or Schema.org structured data, is a collaborative vocabulary built by Google, Microsoft, Yahoo and Yandex to let webmasters embed machine-readable information on their pages. The clue is in the name. It is a schema. A shared, agreed structure that lets a machine know that “Mark Williams-Cook” is a Person, that he works at an Organization called “Candour”, and that the string “01603 957068” sitting in his profile is a telephoneNumber and not, for instance, my weight in grams.

Google’s official documentation puts it about as plainly as Google ever puts anything: “Structured data is a standardized format for providing information about a page and classifying the page content.” Google also says it uses structured data “to understand the content of the page, as well as to gather information about the web and the world in general, such as information about the people, books, or companies that are included in the markup.”

The whole point of schema is to remove ambiguity. Natural language is messy. “Apple” is a fruit, a company, a record label and probably the surname of someone’s gerbil. If you tell a search engine in plain English that you sell Apple, it has to guess. If you tell it in schema that you sell an Organization called “Apple Inc.” with sameAs linking to Apple’s Wikipedia page, that ambiguity collapses to nothing. That is the job. Disambiguation. Explicit clues. Machine-resolvable identity. It is, basically, a polite contract between you and a machine saying “let’s both agree what this word means, just this once”.

Where does the ambiguity actually get resolved? In Google’s case, into the Knowledge Graph, the giant entity-and-relationships database that powers knowledge panels, “people also ask”, entity carousels and a hundred other surfaces. Schema is one of the inputs. It is not the only input, and it has never been the only input. But it is a clean, explicit, low-noise one, which is why search engines like it.

Right. That is what schema does for search engines. Now to LLMs, which are a different animal in nearly every way that matters.

Where, exactly, would an LLM even use schema?

There are two camps in the LLM/schema debate, and most arguments collapse into one of them.

Camp 1: Schema is hoovered up during the training of the model and ends up “baked in” somehow.

Camp 2: Schema is read at the moment the LLM live-fetches a page (during retrieval at query time, or via crawls that feed retrieval).

Let’s take them in turn, with appropriate scepticism.

Camp 1: schema gets into training data

I have written about this before, and it was covered by Search Engine Roundtable last year. The short version is that this is the most popular theory and also the one with the weakest mechanical case behind it. There are two problems, and neither of them is small.

Problem 1: schema is almost certainly stripped before training

If you have not gone down the rabbit hole of how base LLMs are actually made, Andrej Karpathy’s three and a half hour deep dive on LLM pre-training is the canonical reference, and yes, three and a half hours is the deal.

Pre-training pipelines do a lot of unglamorous cleaning work before a single GPU sees the data: URL filtering, language filtering, deduplication, removal of personally identifiable information, and crucially, stripping out HTML and boilerplate. The goal is not to preserve the page. The goal is to extract clean prose that helps the model build a useful probability distribution over language. The more noise (markup, navigation, footers, scripts, JSON-LD, your cookie consent banner) you leave in, the worse the resulting model. So they don’t.

The widely used FineWeb dataset (15 trillion tokens, derived from 96 Common Crawl snapshots) is refreshingly explicit. Their pipeline extracts text from the WARC files using trafilatura, a library specifically chosen because it produces “the main page text” with “less boilerplate and menu text” than the alternatives. The data card states: “We then extracted the main page text from the HTML of each webpage, filtered each sample and deduplicated each individual CommonCrawl dump/crawl.” JSON-LD lives in a `<script>` tag. Trafilatura is, by design, deeply uninterested in `<script>` tags. The unavoidable inference is that JSON-LD does not make it into the training corpus at all. It is binned with the analytics snippets, where it has been keeping good company.

You might reasonably ask: then how can ChatGPT write schema markup for me when I ask it? Because there are millions of examples of schema in visible prose across the web. Tutorials. Documentation. Forum posts. GitHub repos and Stack Overflow answers. Code blocks in blog posts. The model learns what schema looks like the same way it learns what a Python function looks like, by reading endless explanations of it, written by humans, in paragraphs. The schema on your actual product page, sitting silently in the head of the document doing its proper job, gets thrown straight out.

Problem 2: even if it survived, it would not work the way you think

Let’s be generous and stipulate that some non-trivial amount of raw schema does sneak into a model’s training data. We do not actually have full transparency from frontier labs about what they ingest, and the courts have not exactly been kind on this point. Meta’s training pipeline is currently being picked apart for allegedly using LibGen, a pirate library of around 7.5 million copyrighted books. If the frontier labs are happy to swallow other people’s novels whole, they are probably not above swallowing the odd <script type=”application/ld+json”> along the way.

Even if this was the case and our precious JSON-LD schema made it into the training data, it would not be unscathed.

Here’s the catch: The model does not memorise pages. It does not have a little filing cabinet labelled “Candour Agency Ltd” with the address tucked inside. What actually happens is this:

1. All the text in the training corpus gets chopped into tokens (chunks of characters, often parts of words).

2. The model is shown billions of small windows of tokens and asked to predict the next one.

3. Each time it gets it wrong, billions of tiny numerical weights inside the network are nudged so it would do slightly better next time.

4. After enough nudging, those weights collectively encode a (lossy, blurry, statistical) impression of which tokens tend to follow which other tokens, in what contexts.

That is what is stored. Weights. Not facts. Not addresses. Not your postalCode. A glorified probability distribution that has read a great deal and remembers, with the same fidelity as someone trying to recall the lyrics to a song they last heard in 2011, which words usually follow which other words.

This is where schema specifically falls apart. The whole point of schema was to take a string like “77 The Muddy Bank” and tag it explicitly as a streetAddress belonging to a PostalAddress belonging to your Organization, so a machine cannot mistake it for anything else. When that JSON-LD is tokenised, the structure dissolves. The string “@type”: “Organization” becomes a sequence of tokens including @, type, :, Organization, completely indistinguishable, to the model, from the same word soup appearing in any blog post about schema. The disambiguation, which was the entire reason for using schema in the first place, is the very first thing thrown out by the very first stage of training. Marvellous.

Worse still, an LLM only “recalls” a fact if it has seen it many, many times. A single mention of your address on a single product page is a vanishingly small drop in a fifteen-trillion-token bucket. Even if it survived ingestion, you would also need the model to encounter your streetAddress enough times that those particular weights actually settle into a useful pattern. For >99.99% of businesses, that does not happen. The fact is not stored. It will not be recalled. You are paying a consultant to whisper your postcode into a hurricane.

So if you are buying the “schema gets baked into the model” theory, you are buying improbabilities in a trench coat: that it survives pre-training cleaning, that it survives tokenisation with its structure intact, and that it gets repeated often enough across the web for the model to actually “learn” it. None of the three is obviously true.

Camp 2: schema gets read at query time

I’ve experienced that it is rare for any LLM/schema proponents to want to discuss training data involvement once it has been gently set on fire. The argument tends to move quickly onto the possibility that schema is not in the model itself, but is read at the moment a user asks a question, when the LLM fetches the page in real time. Let’s examine the three flavours of this argument in increasing order of confidence and distressing level of inaccuracy.

Flavour 1: "Schema feeds the knowledge graph"

Google’s Knowledge Graph is a vast, curated, slow-moving database of entities and relationships. It is fed by structured data, Wikipedia, Wikidata, freebase legacy data, and a hundred other signals. It is built and updated by Google’s pipelines on Google’s schedule. It is not assembled on the fly when someone types a question, no matter how briskly they type.

The notion that an LLM “builds a knowledge graph in real time when pages are fetched” sounds a lot less reasonable when you say it out loud into the mirror. Knowledge graphs are constructed entities. They have IDs. They have relationship cardinality rules. They have to be reconciled against existing entries so you do not end up with three drifting “Apple Inc.” nodes filing different tax returns. None of that happens between a user pressing enter and the answer appearing on screen. It cannot. There is not enough time, and there is no infrastructure exposed in the chatbot product to do it.

So if an entity-resolution pipeline exists at any of the frontier labs, it is being built upstream, on a similar cadence to Google’s, and not during your conversation. Which is fine, but it does not match the breathless claim that “your schema feeds the LLM’s brain”. Conceptually, the strongest version is closer to “your schema may eventually feed a curated database that the LLM might one day consult”. Which is a much weaker claim, and one for which there is, at present, no public evidence whatsoever.

Flavour 2: "Microsoft confirmed schema feeds Copilot"

Misquoted to an industrial scale, Search Engine Land’s write-up ran under the headline “Microsoft Bing/Copilot use schema for its LLMs”, in which Fabrice Canel of Microsoft was reported to have “confirmed” that schema markup helps Microsoft’s LLMs. Cue half of LinkedIn pasting the headline as proof, often without troubling the body copy.

If you read the actual quote, it is about IndexNow:

It is “your page changed, here is its new state, please come look”. Fabrice was making a point about freshness (telling search engines when your content has changed so they can update their understanding) and not a point about JSON-LD being deferentially parsed by GPT-flavoured systems. Conflating the two is a textbook example of the industry’s favourite parlour trick: take a careful claim about one thing, sand the edges off it, and resell it as a bold claim about something else entirely.

Flavour 3: "LLMs return information that was only in the schema, therefore they use schema"

This is the one that prompted the experiment. It is also the single most-cited piece of “evidence” in GEO LinkedIn posts, and the most easily falsified once you spend half an afternoon thinking about it.

I built a deliberately silly test page about a fictional duck t-shirt company called DUCK YEA at i83.uk/duckyea.html. The visible content of the page mentions no address. Tucked into the head of the HTML, inside a <script type=”application/ld+json”> tag, sat the following:

A few things to notice. The @context is a made-up URL that does not resolve to anything (the great pond, sadly, has no API). The @type is not a valid Schema.org type. Not a single one of the properties (flockName, waddleStyle, nestingGrounds, reedNumber, puddle, featherCode, quackVolume) exists in the Schema.org vocabulary. The JSON is syntactically valid JSON, but as far as Schema.org is concerned this is unmitigated nonsense, the digital equivalent of someone speaking French very loudly while only knowing the words for “cheese” and “weasel”. A well-behaved schema-aware parser should look at this, sigh, and ignore it.

I then asked ChatGPT and Perplexity, “what is the address of this company?”, pointing at the URL.

Both happily returned: Reed Number 77, The Muddy Bank, South Pondshire, DK99 YEA, United Queendom.

Perplexity even helpfully volunteered that it had found the answer “in the page’s embedded structured data”, with the satisfied air of a student who had clearly read the prescribed material. Neither of them flinched at the fact that none of the schema was real, because (and this is the entire point of the exercise) they were not parsing it as schema. They were doing what LLMs always do: reading the visible-ish text of the page, picking out the bit that looked like an address, and presenting it. The JSON-LD wrapper was, to the model, just slightly weirdly-punctuated prose. If I had wrapped the address in <marquee> tags and surrounded it with ducks emoji, it would have made precisely no difference.

If LLMs were genuinely parsing JSON-LD with any reverence for the Schema.org vocabulary, my made-up types and properties would have been rejected, or at the very least flagged. They were not. The information was just lifted straight out of the HTML, dusted off, and served up with confidence. Quack. 🦆

In the interest of not committing the exact sin I am accusing the GEO crowd of: the duck experiment proves that LLMs returned content from a JSON-LD block with a made-up @context, a made-up @type, and no real Schema.org properties. What it does not, on its own, prove is that LLMs ignore schema entirely. A system that consulted schema and fell back to text extraction would produce the same answer here.

If you run the same query today, you get a slightly different result:

The model now (correctly) flags that this is a test page made by some SEO bloke, charmingly demonstrating the AI Convergence Problem doing its thing in real time: enough people have written about the experiment that “DUCK YEA is a joke page by Mark Williams-Cook” is now getting pulled during RAG, and the consensus answer has overwritten what would otherwise be a clean test. The address is still being read from the HTML, schema validity be damned. The model has just learnt to caveat it. Which is, in a small and slightly bleak way, progress.

Conjecture: could LLMs be using schema, somehow, somewhere?

The honest answer is that we do not know what is happening upstream at OpenAI, Anthropic, Google DeepMind, xAI and the rest, because they are not telling. Google itself is a sprawl of separate systems (the index, re-rankers, glue, the knowledge graph, AI Overviews, AI Mode) which all work together to produce what looks, from the outside, like a single coherent answer, and on a good day actually is one. There is no reason in principle why an LLM provider could not run an entity-extraction pipeline against the web, build its own entity store, and consult it at answer-generation time. That is conceptually adjacent to how retrieval-augmented generation (RAG) works, and it is the kind of thing you would absolutely build if you were OpenAI and you wanted to stop your model confidently inventing the wrong CEO.

If they are doing that, schema is an excellent and obvious input. It is explicit, structured, low-noise, and already widely deployed. It would be daft for them not to use it.

But here is the big “but”. We have no published evidence, no leaked papers, no public confirmation, and no behavioural test result that any frontier LLM is actually doing this yet. Reasoning forward from “they probably should” to “therefore schema is worth £20k of consultancy this quarter” is exactly the kind of fact-light, vibe-heavy thinking that the discourse needs less of. Make the case, by all means. But label it conjecture, not evidence. Use a different font.

Google still hasn’t solved this problem reliably

There is also a slightly awkward elephant standing quietly in the corner of the room. If anyone on earth were going to crack the “feed an entity-resolved knowledge graph into an LLM’s answer pipeline” problem first, it would surely be Google. They have over a decade head start on entity extraction approach. They have the Knowledge Graph. They have Google Business Profile, which is a user-edited, structured, ostensibly authoritative database of business information. They own the model (Gemini). They own the surface (AI Overviews). They own the search index that wraps around it. Every page on the planet eventually walks past one of their crawlers. If joining structured business data to LLM output is supposed to be the obvious next step in the human story, Google has every conceivable advantage in being the one to demonstrate it.

And yet:

That is a single Google search result page. On the left, Google’s AI Overview confidently asserts that Perrys Dover Mazda is “not closed”, lists the address, and helpfully provides opening hours, presumably so you can pop down and have a look at the cars that are no longer there. On the right, on the same page, the Google Business Profile knowledge panel for the exact same business is labelled “Permanently closed” in a large, unambiguous red banner. Google Business Profile data is structured. It is user-edited. It is the closest thing Google has to a verifiable, authoritative source on whether a business is, in fact, open. And the AI Overview, generated on the same SERP, by the same company, in the same session, is not consulting it. They are two organs of the same body that have not been on speaking terms for some time.

If the company with the longest possible head start, the most structured data, the most obvious commercial incentive, and full vertical integration over every part of the stack cannot reliably wire its own business-hours database into its own AI answers, the idea that OpenAI or Anthropic have quietly built a richer entity pipeline that does defer to your Organization schema is, let us say, optimistic.

So... should you still use schema?

Yes. Just for the right reasons and the right price.

Schema is, in the grand scheme, still a stopgap. It exists because the technology cannot yet reliably read human language without ambiguity, and structured data is how we paper over the gap while the engineers work out how to read English properly. Gary Illyes from Google, speaking at an SEOFOMO meetup in 2025, pointed out (paraphrasing) that it would be lovely if Google did not have to rely on schema at all, because in an ideal world the systems would simply understand the page. Schema buys you a bit of certainty in the meantime, which is worth something even if it is not worth the consultancy invoice you may have been quoted.

The recent Ahrefs study, which tracked 1,885 cited pages that newly added JSON-LD and matched them against 4,000 controls, found that schema had essentially no effect on AI citations across ChatGPT, AI Mode and AI Overviews. That sounds damning, and a number of LinkedIn carousels are already enjoying themselves accordingly. But as Gianluca Fiorelli pointed out in his excellent critique, the study tested pages that were already being cited heavily by AI (every page in the dataset had 100+ AI Overview citations before treatment). That is the worst possible population to test schema on, because these are already strong, well-understood entities. Schema’s job is to disambiguate. If the system can already resolve who you are with high confidence, adding Organization schema is solving a problem the page does not have. You don’t introduce yourself by name to your own mother.

The interesting case, and the one nobody has properly tested, is the new and challenger brands, where the entity footprint across the web is thin and the system cannot yet confidently say “this company is the company you mean”. For those, schema is infrastructure. It is how you become a resolvable node in the graph in the first place. It does not buy you a citation today. It earns you the right to be one of the candidates tomorrow, which, in a world where being a candidate is suddenly the only game in town, is no small thing.

Takeaways

A few practical thoughts, dressed down for tactical use:

• Still use schema. The implementation cost is low, the downside is essentially nil, and the upside is cumulative. If schema does end up being meaningfully ingested at any stage of the LLM stack (and it might), the work is already done and you can be smug about it. Free smugness is the best kind.

• Stop selling schema as a magic LLM citation lever. The current public evidence for LLMs using schema “as intended” at query time is, frankly, weak. Anyone telling a client otherwise should be politely asked to show their working, in front of other people, with a whiteboard.

• Be ruthless about the bar of evidence. “An LLM returned a fact that appears in the schema” is not evidence the schema was used. The same fact almost always appears in the HTML, the metadata, the page title, the social card, or somewhere a token predictor would gleefully pick it up. The duck experiment matters precisely because the schema was invalid and the LLMs returned the answer anyway. If your “proof” survives that test, talk to me. If it doesn’t, please stop putting it on slides.

• Focus schema investment where disambiguation actually matters. New brands. Brands with name collisions. Organisations without a knowledge panel. Personal entities that overlap with other people who share their name and have been more famous for longer. That is where the asymmetric upside lives.

• Treat “GEO best practice” the way you would treat any other new SEO orthodoxy. Sceptically, with experiments, and with a willingness to revise the position when the evidence changes. The car-wash-grade reasoning on LLMs, where the popular answer just gets repeated until it sounds true, is alive and thriving in our industry too.

Further reading and references

• Schwartz, B. “ChatGPT & Perplexity Treat Structured Data As Text On A Page”, Search Engine Roundtable, Feb 2026.

• Schwartz, B. “Structured Data Does Not Help With Visibility In AI Search”, Search Engine Roundtable, Sep 2025.

• Williams-Cook, M. “The AI Convergence Problem”, 2026.

• Schema.org, “About”.

• Google Search Central, “Introduction to structured data markup in Google Search”.

• Google, “Knowledge Graph Search API”.

• Karpathy, A. “Deep Dive into LLMs like ChatGPT”, YouTube, 2025.

• Penedo, G. et al., “The FineWeb Datasets: Decanting the Web for the Finest Text Data at Scale”, 2024.

• Authors Guild, “Meta’s Massive AI Training Book Heist: What Authors Need to Know”, 2025.

• Schwartz, B. “Microsoft Bing/Copilot use schema for its LLMs”, Search Engine Land, Mar 2025.

• IndexNow, indexnow.org.

• Linehan, L. & Guan, X. “We Tracked 1,885 Pages Adding Schema. AI Citations Barely Moved.”, Ahrefs Blog, May 2026.

• Fiorelli, G. “The Ahrefs Schema study is right. And it’s testing the wrong thing”, iloveseo.net, May 2026.

• SEOFOMO, “What’s new in SEO + AI Search? Read SEOFOMO June 15, 2025”.

Allow me to gently push back, armed with the classic mspaint.exe

There are two problems with the “let the robot decide” school of marketing, and they are mirror images of each other. Where LLMs are weak, they are very stupid in ways that should disqualify them from strategic work. And where they are strong, they are even more dangerous, because they will quietly drag your strategy towards the average; which, in marketing, is the single worst place you can possibly be.

LLMs don’t think, they predict the next token

Let’s start with the bit that the AI labs would rather you didn’t dwell on. Large language models do not “think” in any meaningful sense. Under the bonnet, they are statistical machines that predict the most probable next token given the sequence so far. That is the entire trick. There is no inner monologue, no model of the world, no quiet moment where the model goes “hang on, that doesn’t add up”. There is only: given these tokens, what tokens usually come next?

This is not a hot take from a sceptic on Substack. Apple’s research team published a paper with the gloriously blunt title “The Illusion of Thinking“, in which frontier “reasoning” models hit a complete accuracy collapse once puzzle complexity rose beyond a certain threshold and, even more damningly, started using fewer tokens as problems got harder, as though giving up. Apple researchers had previously shown in GSM-Symbolic that simply adding a clause to a maths problem that didn’t even change the answer could drop performance by up to 65%, suggesting that what looks like reasoning is mostly pattern-matching against training data. A more recent taxonomy of LLM failures groups these into things like the “reversal curse” (knowing “A is B” but failing on “B is A”) and “compositional collapse” (solving each step individually but failing to chain them), all flowing from the next-token prediction objective prioritising statistical pattern completion over deliberate reasoning.

This basically means if your problem looks like something the model has seen a million times, it will appear brilliant. The moment your problem is even slightly novel, the wheels can come off in spectacular fashion.

Exhibit A: the car wash

The cleanest demonstration of this in the wild is the now-infamous car wash prompt:

“I want to get my car washed. The nearest car wash is 100 metres away. Should I walk or drive there?”

We’re hovering around Ralph Wiggum levels of reasoning here, a question most 5 year olds would not struggle with. You need the car to be at the car wash, because the car is the thing being washed. The car cannot be washed in absentia while you stroll there on foot, no matter how good your intentions.

When this prompt went viral, ChatGPT, Claude and Grok all confidently advised the user to walk. It’s only 100 metres, they reasoned (or “reasoned”). Save the planet. Get some steps in. They had clearly seen a great deal of training data along the lines of “should I drive or walk to [short distance]?” and dutifully predicted the tokens that usually follow: a polite lecture about exercise and emissions. The actual point of the question - that the car is the object of the verb - sailed past them at altitude.

Gemini, to Google’s credit, got it right out of the gate. Suspicious, I thought. And it was. The prompt had gone viral, which meant the correct answer was already being written about, posted about and dunked-on across the internet. Google, helpfully sitting on top of the index of that internet, was first to hoover up the new “knowledge”. A fortnight later, Grok also produced the correct answer, not because it had had a Damascene conversion to logic, but because the answer was now in its training data.

The models didn’t learn to think. They learnt the answer.

This is the key thing to internalise before we go any further. When an LLM appears to “reason”, what you’re often watching is it reciting the consensus answer to a problem that lots of people have already solved on the internet. Which is fine when you want the consensus. It is catastrophic when you don’t.

And now the worse problem

Here is where most “AI in marketing” posts stop. They wag a finger at the car wash, suggest you keep “a human in the loop”, and head off to write a LinkedIn post about it (probably with ChatGPT).

But the failure modes are the comfortable bit. The dangerous bit is what happens when the LLM is good at the task you’ve given it.

Because if a model is “good” at a task, it means there is a great deal of training data showing it how the task is normally solved. And if it has consumed all of that training data - alongside every other frontier model, all trained on roughly the same scrape of the internet then the output it produces will, almost by definition, sit somewhere very close to the mean of what everyone else is already doing.

In marketing, that is the worst sin you can commit. The whole job is to stand out. To be chosen. To be remembered. The instant your brand voice, your campaign idea, your headline or your “10 SEO tips for 2026” article is indistinguishable from your competitor’s, you have stopped doing marketing and started doing wallpaper.

Jeremy Daly summarised the underlying mechanic neatly: convergence is a function of shared data, shared incentives and fast iteration loops. When three companies pour the same training data into the same model, optimising for the same engagement metrics, on iteration cycles tight enough to sand the rough edges off any deviation, you don’t get differentiated strategies — you get the same strategy in three brand colours.

This is not just a vibe. Researchers from Columbia and MIT found that handing identity-defining choices to LLM agents shifts people’s choices toward more popular options, reducing the distinctiveness of their behaviours and preferences. They called it, with admirable honesty, “The Basic B*** Effect”. A separate study published in Science Advances showed that generative AI enhances individual creativity but reduces the collective diversity of novel content - each writer’s story got a little better, but across the population, the stories started to look the same. And work on LLM “mode collapse” has documented the same homogenisation pattern at the level of the model itself: the same few completions, again and again, even when many valid answers exist.

Put plainly: the very thing LLMs reward you for: speed, fluency, consistency, “best practice” is the thing that will quietly turn your marketing into beige.

Exhibit B: Parliament has been LinkedIn-ified

If you want to see what convergence looks like in the wild, look no further than the House of Commons.

The Pimlico Journal analysed every word spoken in Hansard from 2007 to 2025 and tracked the Z-score frequency of phrases that are tell-tale ChatGPT tics. “I rise to speak”. “Is not merely”. “Navigating”. “Underscores”. “Streamline”. “Not just a [X], but a [Y]”. “Bustling”. Phrases that pootled along the baseline for fifteen years and then, almost to the week of ChatGPT’s release in late 2022, shot vertically off the chart. “I rise to speak” alone hit a Z-score of 3.60 by 2025. The Telegraph picked the story up under the headline “ChatGPT triggers surge in MPs using AI-written speeches”.

Set aside the democratic implications for a moment (they are not good). Look at it purely as marketers. These are 650 individuals, each with their own constituency, their own pet causes, their own carefully cultivated personal brand, each ostensibly trying to be memorable enough to stay employed at the next election. And after handing the drafting work to an LLM, they have started to sound like the same person. The same person who, incidentally, also writes every other LinkedIn post you’ve ever scrolled past.

That is convergence. It does not require a conspiracy. It does not require anyone to be lazy or stupid. It just requires the inputs (the same training data), the incentives (the same metrics), and the loops (publish, see what works, repeat) to be roughly similar across users. Which, in marketing, they almost always are.

Now imagine the same chart for your category page H1s. Your meta descriptions. Your blog intros. Your campaign concepts. Your tone-of-voice guidelines. Your “thought leadership”. Your client pitch decks. Then ask yourself, honestly, what is left for the customer to choose between.

Exhibit C: tactical mspaint.exe on LinkedIn

I have, by accident, run my own counter-experiment.

For the past while, I have been posting unsolicited #SEO tips and Core Updates round ups on LinkedIn, accompanied by absolutely terrible MS Paint drawings. Not stylised “playful illustrations” produced by some agency. Genuinely bad pictures of a stick-man labelled “SEO” pointing at a robot labelled “GSC”, drawn in mspaint.exe by someone who should not be allowed near a graphics tablet.

The post above did 35,363 impressions, 448 reactions, 46 comments and 24 reposts. Not because the drawing is good - it is, objectively, not - but because it is unmistakably hand-made on a platform that has been carpet-bombed by AI-generated hero images, all of which appear to depict the same diverse team of smiling professionals high-fiving in front of a holographic dashboard.

One of the most common comments I get is some version of “I love these images, they feel warm” or “something about making things your own”. Which is exactly the point. There is a growing, almost feral hunger for content that is demonstrably human-made; content that signals “an actual person sat down and did this, on purpose, for you”.

Or, as Tyler Durden put it in Fight Club:

“the glass dishes with tiny bubbles and imperfections, proof they were crafted by the honest, simple, hard-working indigenous peoples of wherever”

That line was originally a joke about middle-class consumerism. It is now, somehow, a viable LinkedIn content strategy.

What this means for digital marketing

Right. So what do you actually do with this, beyond nodding sagely and going back to prompting?

Use LLMs where they are good, on purpose, and accept the mean. For commodity work: fixing alt text at scale, summarising a meeting, drafting a polite reply to that client who is technically wrong. LLMs are excellent here and the cost of being average is zero. Nobody is going to choose your brand based on the quality of your internal Slack summary. Use the tool, save the time, move on.

Refuse to use LLMs where average is fatal. Brand positioning. Headlines. Hooks. Campaign concepts. Tone of voice. Editorial angles. Anywhere a human is going to make a choice between you and a competitor. If you let the model decide, you are explicitly choosing to be the average of everyone in your training corpus. There is no universe in which “be the average of your competitors” is the right strategy.

Treat LLM outputs as a baseline to deliberately diverge from. A useful exercise: ask the model for its first answer, then ask “what would the opposite of this look like?”, then ask “what would only my brand do here?”. The model’s first instinct is the consensus. Your job is to know what the consensus is so you can choose not to be it.

Invest in inputs the model does not have. Proprietary data. First-hand customer interviews. Your own experiments. Internal opinions that haven’t been blogged about. These are the moats. If your “insight” is anything a competitor can extract from a public scrape, it is not an insight, it is wallpaper. (Jeremy Daly’s convergence map makes the same point from the software side: convergence pressure is weakest where inputs are asymmetric and feedback loops are slow.)

Put visible human fingerprints on the output. A drawing. A specific anecdote. A weird turn of phrase. A genuinely held opinion that might lose you a follower. The bubbles in the glass. People are now actively scanning content for evidence that a person made it and the bar for “evidence” is low, but it has to be there.

Stop confusing fluency with intelligence. An LLM that produces a paragraph faster than you can read it is not smarter than you. It is faster than you. Those are different things. The car wash question is the canary in the coal mine: anything novel, anything that requires actually modelling the world, anything where the right answer is not the popular answer, is where you need to switch the machine off and use your own head.

TL;DR

LLMs are token predictors with excellent diction. Where they are weak, they fail in ways a child wouldn’t and confidently tell you to walk to the car wash, because that’s what the words usually say. Where they are strong, they fail in a quieter and more expensive way: they pull every user gently towards the same mean answer, which in marketing is the one thing you cannot afford to be.

This is the AI Convergence Problem. Shared data plus shared incentives plus fast feedback loops equals everyone sounding like everyone else. We can already see it in creeping into our very government. We will see it in your category. The question is whether your strategy is the one being averaged out, or the one people are reaching for because they can no longer stand the beige.

Don’t think like a robot.

Further reading and references

• Shojaee, Mirzadeh et al., “The Illusion of Thinking: Understanding the Strengths and Limitations of Reasoning Models via the Lens of Problem Complexity”, Apple Machine Learning Research, 2025.

• Mirzadeh et al., “GSM-Symbolic: Understanding the Limitations of Mathematical Reasoning in Large Language Models”, arXiv, 2024.

• Matz, Horton & Goethals, “The Basic B*** Effect: The Use of LLM-based Agents Reduces the Distinctiveness and Diversity of People’s Choices”, arXiv, 2025.

• Doshi & Hauser, “Generative AI enhances individual creativity but reduces the collective diversity of novel content”, Science Advances, 2024.

• Anschel et al., “Group-Aware Reinforcement Learning for Output Diversity in Large Language Models”, EMNLP, 2025.

• Jain et al., “Task-Dependent Evaluation of LLM Output Homogenization”, 2025.

• Pimlico Journal, “MPs are almost certainly using ChatGPT to generate Commons speeches”, 2025.

• The Telegraph, “ChatGPT triggers surge in MPs using AI-written speeches”, 2025.

• Jeremy Daly, “The Convergence Problem: Rethinking the 2028 Global Intelligence Forecast”, 2026.

• Reddit r/PromptEngineering, “I asked 5 popular AI models the now viral car wash question”, 2026.

Leave a comment