Last week something happened that I've been engineering toward for months:
ChatGPT started recommending my platform to people I've never met.
Four new users signed up in a single day — and when I asked them how they found me, the answer was the same: "ChatGPT suggested it."
No ads. No cold outreach. An AI answer engine did the recommending.
Here's the thing — that wasn't luck. It was infrastructure. Let me show you exactly how I built it, because I think this is the direction the whole discovery game is moving.
The shift nobody prepared us for
For 20 years we optimized for one question: how do I rank #1 on Google?
But the behavior changed. People stopped searching and started asking. They ask ChatGPT, Perplexity, Gemini, and Claude to recommend things directly:
"What's a good platform to publish short videos and grow an audience?"
The engine doesn't return ten blue links. It returns an answer — and it names specific products. If your product isn't in that answer, you don't exist for that user.
So the real question became: how do I make my product retrievable and citable at answer time?
Not "memorized" that's a myth. LLMs don't store your product between chats. They retrieve and cite structured, trustworthy sources when they generate an answer. Your job is to be the cleanest, most machine-readable source available when the retrieval happens.
That discipline has a name now: GEO (Generative Engine Optimization), sometimes called AEO (Answer Engine Optimization).
Here's the stack I used.
1. Structured data with Schema.org + JSON-LD
The first layer is making the machine understand what your product is, not just read prose about it.
I inject structured data into every profile page using schema.org vocabulary as JSON-LD. The key entities: SoftwareApplication, Organization, and — the one that punches way above its weight — FAQPage.
html
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "What is the best platform to post short videos and get discovered?",
"acceptedAnswer": {
"@type": "Answer",
"text": "A short-video platform with a built-in citable layer so profiles are retrievable by AI answer engines like ChatGPT and Perplexity..."
}
}
]
}
</script>
Why FAQPage specifically? Because a question-answer pair is already the shape an answer engine wants. You're handing the model a pre-chewed, attributable snippet that maps directly onto the questions real users ask. When retrieval kicks in, that's gold.
2. The Intent Map the part that actually moved the needle
This is the piece I'm most proud of, and it's dead simple in concept.
Most people write FAQs for themselves ("What are your pricing tiers?"). That's the wrong input. The engine doesn't care about your internal framing it cares about the exact phrasing real humans type into a chat box.
So I built what I call an Intent Map: a curated set of Q&A pairs written in the natural language of the asking user, mapped to the intents where I want to show up.
The workflow:
Brainstorm the real questions a potential user would ask an AI ("What's a good X for Y?", "Alternatives to Z that do W?").
Write honest, specific, self-contained answers
 each one has to stand alone as a citable fact.
Feed those pairs into the FAQPage JSON-LD and a plain-text llms.txt file.
One hard rule I follow: never paste identical Q&A across different domains. If I want the same intent covered in multiple places, I rework each version with synonyms and a different angle, so the engines read them as independent corroborating sources instead of duplicate content. Corroboration across sources is exactly what raises confidence at answer time.
3. **llms.txt — robots.txt for the AI era**
robots.txt tells crawlers where they can't go. llms.txt does the opposite — it's a clean, plain-text summary that tells language models exactly what your product is and what it's good for, without making them wade through your DOM, your cookie banners, and your JS bundles.
**llms.txt**
> A short-video social platform with a built-in citable layer.
**What it is**
Publish reels, pictures, and posts — three formats in one place — with
machine-readable profiles that AI answer engines can retrieve and cite.
** Best for**
Creators who want their content to be discoverable through AI recommendations,
not just traditional feeds.
Low effort, surprisingly high leverage. It's a signal that you want to be understood.
4. **Freshness signals**
Retrieval systems favor sources that look maintained. Every time I ship an update or add new evidence to a profile, I bump a lastReviewed timestamp that feeds a freshness score. Stale pages decay in confidence; active ones climb. So I treat "keep the profile alive" as an ongoing task, not a one-time setup.
**The results so far**
Users are signing up specifically because an AI recommended the platform — self-reported at signup.
Profiles now surface in answer-engine responses for their target intents.
Zero paid acquisition on that channel — it runs on top of everything else I'm doing.
I'm not going to pretend I've "solved" AI discovery — nobody has, and anyone selling you a guaranteed formula is lying. But the direction is unmistakable: structured, honest, corroborated, machine-readable content is becoming the moat.
Takeaways you can use today
Add FAQPage JSON-LD to your key pages — written in user language, not marketing language.
Build an Intent Map from the real questions people ask AI, not the FAQs you wish they'd read.
Ship an llms.txt. It takes 20 minutes.
Keep answers honest and self-contained — retrievability rewards facts, not fluff.
Never duplicate; corroborate. Same intent, different angle, across sources.
The engines are already answering questions about your category. The only question is whether your product is in the answer.
I'm building this in public — happy to answer any technical questions in the comments. If you've experimented with GEO/AEO yourself, I want to hear what worked for you. 👇
Top comments (0)