When your next customer asks an AI about you instead of Googling — what does it say? Ten steps to make the answer one you'd be proud of.
For twenty-five years, the web rewarded whoever shouted loudest into a search box. You optimised for a human scanning ten blue links. That human is quietly being replaced by an agent — a model that reads the web for them, decides what's true about you, and delivers a verdict in a sentence or two. The customer never sees the ten links. They see the model's answer.
This is the shift behind the noise about "AI search" and "GEO." Strip the jargon and it's simple: discovery is now mediated by something that cannot be charmed, only convinced. It does not respond to a clever headline. It responds to whether your claims are structured, corroborated, and consistent enough to be repeated with confidence.
Most founders are still writing for the human and wondering why the machine ignores them. The few who adapt early get a compounding advantage — because the model's confidence in you grows every time the web agrees with itself about who you are.
Attention used to be the asset. Now interpretation is. The question is no longer "can they find me?" — it's "when the machine explains me, does it get it right, and does it sound impressed?"
What follows is the protocol. Ten steps, ordered. Each one is something you can do — not a theory to admire. None of it requires being famous. It requires being legible: the rare founders who win the next decade are not the loudest, they're the ones a machine can describe without hedging.
You don't have to take this on faith. The studies converge on one uncomfortable truth: the machine's answer is decided by signals most founders never touch.
Read that last number twice. The machine mostly cites things you can already control — your site, your profiles, your structured data. That's the good news buried in the disruption: this is winnable, and it's winnable by you, this quarter.
You cannot fix an answer you've never heard. Before anything else, become the customer. Open ChatGPT, Claude, Perplexity, Gemini and Google's AI overview. Ask each the same fixed questions a real buyer, investor or journalist would ask: "Who is [you]?" · "Is [your company] credible?" · "What does [your company] do?" · "Should I trust them with [the thing you ask people to trust you with]?"
Write the answers down verbatim. Note two things: what it got wrong, and what it could not say at all. The silences matter more than the errors. A confident wrong answer can be corrected; a hedging non-answer means you don't exist as a recognisable entity yet.
An LLM's answer about you is a confidence-weighted summary of the web's consensus. Where the web is consistent, it speaks plainly. Where the web is thin or contradictory, it hedges — or invents. Your job for the next nine steps is to remove every reason for it to hedge.
Keep this transcript. It's your baseline. In Step 10 you'll run the exact same prompts again, and the delta is the whole point.
Here is the single most expensive mistake on the modern web, and it is invisible until you look for it: the major AI crawlers do not run JavaScript. GPTBot, ClaudeBot, PerplexityBot, Google's extended crawler — they read the raw HTML your server returns and nothing more. A slick client-rendered app can look completely blank to them.
Your beautiful site may not exist to the machine. Test it in one line:
If that returns nothing, the crawler cannot see your own name on your own page. Everything else in this guide is wasted until this passes. Move the pages that explain you — about, team, what-you-do, proof — to server-side rendering or static generation. The interactive app can stay client-side; the narrative cannot.
Want the answer in seconds instead of a grep? We built a free, open-source scanner that fetches your site exactly as an AI crawler does and scores how legible you are. No install, no signup — one line in your terminal for an instant, verifiable credibility check:
It's on GitHub, free to read and run: github.com/KirkeLabs/ai-legibility-scan. Run it on yourself today; a passing score is the fastest proof you've done the work.
Founders spend months on positioning copy that the machine has literally never read because it lives inside a JavaScript bundle. The most elegant sentence in the world, rendered client-side, is silence.
The machine builds confidence through repetition. When your bio on Crunchbase, your LinkedIn summary and your site's about page all say the same thing in the same words, the model concludes — correctly — that these are one consistent entity. When they drift, it reads ambiguity, and ambiguity is the enemy of a confident answer.
So write one canonical description. Roughly two hundred words. Four moves: who you are now · your single most corroborated proof point (stated factually, never inflated) · the depth behind you (the experience or body of work that's hard to copy) · the throughline that connects them. This paragraph becomes the spine of every profile you touch from here on. You paste it verbatim. You do not "freshen it up" per platform.
Consistency is not a stylistic preference here — it is the ranking signal. Five identical bios outperform five clever ones, because sameness is what a machine reads as a single, trustworthy fact.
One discipline that decides whether the machine takes you seriously: lead with the rigorous, checkable language and keep the evocative language for the long-form essay later. The model meets your first sentence with a credibility heuristic. Give it precision, not poetry.
Prose tells a human what you are. Structured data tells a machine the same thing without it having to guess. Schema.org JSON-LD is a small block of labelled facts you embed in a page: this is a Person, this is their jobTitle, these other profiles are the sameAs them. It removes interpretation from the parts you cannot afford to have interpreted.
Add three blocks: a Person for the founder, an Organization for the company, a Product or Service for what you sell. The single highest-value field is sameAs — the list of every other place you exist online. It is the thread you'll pull tight in Step 6.
Then validate it — paste each page into a free schema validator and fix every error. Invalid structured data is worse than none: it signals carelessness to precisely the systems you're trying to impress.
An AI does not reason about you as a person it's getting to know. It resolves you as a node in a knowledge graph — a "thing" it has a confident record of, or doesn't. The fastest route into that graph is not Wikipedia (its bar is high and a failed attempt can backfire). It's Wikidata, the structured database that feeds Google's knowledge panels and the major models' entity resolution.
Wikidata doesn't require fame. It requires that you be clearly identifiable using serious, public references — which is exactly why you create your structured profiles first. A claimed Crunchbase, a verified company page, a real footprint: these are the references that let the entity exist. Create items for the person, the company, the product. Now you are a thing the machine can point to, not a string it has to puzzle out.
A website is something a model reads. An entity is something it knows. The difference shows up as the difference between "I found a site that mentions…" and a confident, unhedged sentence about who you are.
Forcing a Wikipedia article before you're notable can trigger a deletion that "salts" your name — harder to recover from than having no page at all. Wikidata first. Wikipedia is an outcome of Step 8, never a starting move.
You now have scattered profiles, structured data, and an entity record. Step 6 is the move most people skip and the one that does the most work: make them all point at each other. Your site's structured data lists every profile. Every profile links back to your site. Your entity record confirms the whole set. This is a closed loop the machine can walk in any direction and never find a contradiction.
That bidirectional web — site to profiles, profiles to site, entity confirming both — is what converts a pile of mentions into one high-confidence identity. It's unglamorous. It's also the difference between a model saying "there appear to be several people by this name" and it saying exactly who you are.
The goal is not to be everywhere. It's to be the same person everywhere, in a way a machine can verify by walking the links.
Almost every founder has a name collision: another professional with your name, a famous product that shares your brand, a historical term your project echoes. To a model, these are not separate things until you make them separate. Left unaddressed, the bigger entity absorbs you — every mention of you gets quietly pulled into them.
The fix is precise. Wherever you describe yourself, state the distinction in plain language in the first lines: what you are, and explicitly what you are not to be confused with. In structured data, model the relationship honestly — if you're inspired by something, say inspiredBy or about, never sameAs. sameAs means "these are identical"; using it loosely is how you erase yourself.
A collision handled well is not damage control — it's a moat. "The modern X, building on the historical Y" is a sharper, more memorable identity than X alone. The disambiguation is what lets the machine see your distinctiveness instead of flattening it into someone else's record.
Everything so far is brand-controlled, and brand-controlled signals get you most of the way. The last stretch — the part that turns "self-described" into "verified" — needs voices that are not yours. Models weight independent corroboration heavily for trust, and disproportionately so for anything that pattern-matches to risk (money, claims, anything a skeptical reader would want a second source on).
You need a small number of genuine, independent, crawlable references: a piece of real press, an ecosystem write-up, a podcast transcript, a third-party listing that isn't a press release. Three solid ones across different domains move you further than thirty owned posts. Pursue them in parallel; one that lands beats ten in progress.
The highest-leverage version of this: find the door only you can open. Every competitor can get the obvious trade press. Almost none can place a serious essay in a respected publication adjacent to your field, or get covered by an outlet that rarely touches your category. The asymmetric corroboration is worth ten times the generic kind — and it's usually the thing your specific background uniquely qualifies you for.
Here's the failure mode no amount of structured data fixes: the machine compresses. It averages. Generic, polished, "everything to everyone" content gets flattened into the consensus and you become invisible — not wrong, just unremarkable, indistinguishable from the mean. The defence is not more content. It's a position.
Publish one piece of real thinking — a long-form essay that takes a specific, defensible, falsifiable stance you're willing to be associated with. This is the artefact models cite when someone asks an open question in your domain, and it's the thing humans remember you by name for. It resists averaging precisely because it isn't average.
Being legible to the machine keeps you in the consideration set. Having one sharp opinion is what makes the machine — and the human reading its answer — actually name you.
This is also where any genuine depth you carry stops being a footnote and becomes the moat. A competitor can copy your schema in an afternoon. They cannot copy a real point of view earned over years. That asymmetry is the entire game at the top.
Entity work decays if unattended, and you can't improve what you don't measure. Once a month, run the exact prompts from Step 1 again across every model. Log mentioned-or-not and which source got cited. Re-run the Step 2 crawler test after any deploy — rendering quietly regresses. Re-validate your structured data. Check your entity record is intact.
Then watch for the thresholds that change your strategy: when the models start naming you spontaneously for category questions, the work has compounded — shift effort from foundation to the opinion engine. When an independent source cites your essay, you've earned the right to pursue the harder credibility tiers.
The first ninety days are effortful and feel slow. After that it's a flywheel: each piece of corroboration strengthens the entity, which makes the next piece easier to earn, which strengthens it further. Your job stops being "push harder" and becomes "keep the wheel clean and feed it one good thing at a time."
The web didn't get harder. It got honest. The machine in the middle can't be charmed, gamed with a headline, or out-shouted. It can only be convinced — by structure, by corroboration, by consistency, and by one idea sharp enough to survive being averaged.
That's bad news for everyone optimising for the old game, and quietly enormous news for anyone willing to be precise. Most founders will read something like this, nod, and change nothing. The protocol works because of that. The bar is not genius. It's follow-through.
Don't try to be found. Make yourself impossible to misdescribe — then say one thing worth repeating. The machine will do the rest, every time someone asks.
Start with Step 1 today. It takes thirty minutes and it will bother you enough to start Step 2.