We tracked 287 AI answers about AI-visibility tools: builder notes on the new citation layer
A team measured how four assistants answer buyer questions about their own product category. The result isn't a growth-hacking playbook — it's a systems note. Here's what it means if you own architecture, ops, security, or delivery for a website or software product.
What was actually measured
The setup: 24 realistic buyer questions, asked of ChatGPT, Gemini, Perplexity and Claude, in English, French and Arabic. 287 answers collected. For each answer they recorded who got recommended and which sources were cited.
Do the arithmetic first, because it's the most useful line in the whole piece: 24 questions × 4 assistants × 3 languages = 288 expected responses. They got 287. One call didn't come back. That single missing answer is the entire operational story in miniature — you are depending on a non-deterministic, unversioned, un-SLA'd third-party system, and your first integration with it will be defined by its failure modes.
The authors are explicit that this is one brand, one snapshot, a small sample. Keep that framing. What follows treats the study as a signal about shape, not a measurement you can copy into a slide.

图示:来源页预览图(仅作编辑上下文;版权归属原发布方) · 来源引用:dev.to
Finding 1: the citation graph is concentrated
The headline result is skew. Across all 287 answers, a small set of domains did most of the talking; the long tail of the open web barely appeared. The specific list is in the original post, but the structural claim is what matters: citation is a power law, and the head of that distribution is mostly not your domain.
Three consequences for teams:
- Your own site is necessary but not sufficient. You can ship perfect content and still be absent from answers, because the assistant is quoting review platforms, Q&A threads, package registries, docs mirrors and comparison pages instead.
- The surfaces you don't own are deploy targets. A README, a changelog entry, a G2 profile, a Stack Overflow answer, a docs page on a subdomain — those are artifacts with owners, review processes and staleness risk. Most orgs treat them as marketing debris. They are now part of your distributed content deployment.
- Concentration means leverage. If five domains carry most of the citations, a small number of well-maintained third-party artifacts moves the needle more than another twenty blog posts. That is a budget reallocation argument, and it should be made with the caveat that the measurement is noisy.
Finding 2: assistants have different source diets
The four assistants did not converge. Their citation profiles differed in breadth, recency, and which platforms they leaned on. Perplexity-style systems cite heavily and inline; others cite less and lean harder on a narrower set of high-authority domains. Gemini's pool skews toward properties inside its own ecosystem. Non-English queries pulled a materially different set of sources than English ones.
For builders, this means "AI visibility" is not one integration. It's four-plus integrations with different retrieval behaviors, different freshness preferences, and different tolerance for JavaScript. You cannot A/B a single fix and assume it generalizes.

图示:HEXOPS 原创配图(受选题启发,非复制原文图片) · 来源引用:dev.to
Architecture: your rendering pipeline is now an API contract
The most common silent failure in this space is content that exists only after client-side hydration. Retrieval fetchers are not browsers. They don't wait for your React tree, they don't solve cookie consent walls, and they don't scroll.
Practical implications:
- Server-render or prerender anything you want quotable. Prices, limits, compatibility matrices, API references, changelogs. If it requires JS to appear, assume it is invisible.
- Semantic HTML beats div soup. Headings, definition lists, tables with real
<th>scopes,<time datetime>on dated claims. These are cheap to add and cheap to parse. - Stable URLs and stable entities. Renaming
/pricingto/plansevery quarter resets every citation pointing at you. Redirect, but expect a decay window. - One canonical facts page. Versioned, dated, machine-readable-ish: what the product does, what it costs, hard limits, supported platforms. This is the page you want retrieved when someone asks a factual question, and it's the page that saves your support team from answering contradictions.
Ops: you cannot log the model, so build probes
You have no server-side access to the retrieval pipeline. No request logs, no error rates, no deploy hooks. The only observability available is synthetic probing: run a fixed prompt set on a schedule, store the raw responses and extracted citations, and diff over time.
Treat this as a real data pipeline, because it is one:
- Schema first. Prompt ID, locale, assistant, timestamp, model version string if exposed, full response text, extracted citation URLs, extracted brand mentions.
- Store raw. Parsing rules will change. If you keep only the parsed output you lose the ability to re-analyze.
- Run repeats. One sample per prompt per day is noise. Three to five runs, and report variance. The original study's small-n caveat is exactly the discipline you need internally.
- Cost and rate control. These are paid APIs with per-token billing and rate limits. Put it behind a queue with a budget cap, not a cron job that fans out.
- Secret hygiene. API keys in a vault, scoped per environment, rotated. A monitoring job is a credential-bearing workload like any other.
Alert on changes in citation source mix, not just on brand mention count. A drop from a high-authority domain to an anonymous aggregator is a regression even if the mention count is flat.
Security: untrusted content flows both directions
Two threat surfaces, and teams usually only think about one.
Inbound: anything an assistant cites is content someone else controls. If you build internal agents that browse or retrieve, that content is untrusted input — indirect prompt injection is the mechanism. Your agent's tool permissions must be scoped so that a poisoned page can't trigger a write, a spend, or a data egress. Same controls you'd apply to any user-supplied string.
Outbound: the pressure to "publish more so we get cited" collides with least-privilege documentation. Watch for:
- Internal hostnames, staging URLs and ticket IDs leaking into public docs and error messages.
- Secrets or tokens in public repos, example configs, and CI logs.
- PII in changelogs, case studies and support-forum answers.
- Over-precise claims. If an assistant repeats "supports X" and you don't, that's a support and possibly legal cost. Keep public claims narrow and current.
Also audit your edge. Bot management, WAF rules and default CDN configurations frequently block AI crawlers without anyone deciding to. That is a product decision, not a config default. Whether to allow or block AI user agents belongs in a written policy with an owner — silently 403ing a distribution channel is an outage you won't notice.
Delivery: locale is a separate source graph, and non-determinism breaks CI
The multilingual dimension is the most underrated part of the study. French and Arabic queries surfaced different sources than English ones. That means localization is not a translation step bolted onto the end of the pipeline — each locale has its own third-party ecosystem you need a presence in.
Delivery implications:
- Per-locale source tracking in whatever you use for content ops. Don't assume the English citation profile describes the German one.
- hreflang and locale-stable URLs so the right variant is retrievable.
- RTL correctness for Arabic as a rendering requirement, not a nicety.
- Don't gate on non-determinism. Never put "the model said X" into a CI assertion or a release gate. Assistants change behavior without notice. Snapshot tests against model output will flake and then get muted, which is worse than not having them.
- Treat answer-monitoring output as a report, not a deploy trigger. Humans read trends; pipelines read schemas.
What we'd do in the first two weeks
- Crawl your own site with JS disabled and confirm every commercially relevant page renders as text.
- Inventory the third-party artifacts that describe you — review profiles, package READMEs, docs mirrors, comparison pages — and assign each an owner and a review cadence.
- Write the canonical facts page and link it from everywhere.
- Stand up a 20–30 prompt probe set across your top two locales, three repeats, raw storage, a weekly diff.
- Audit edge and robots config for accidental AI-crawler blocks, and write down the decision either way.
- Review public docs for internal hostnames, secrets and stale claims.
Caveats worth repeating
One brand. One snapshot. 24 questions. 287 answers. Three languages. Queries were brand-adjacent, which biases toward the sources that already discuss that category. None of this is a benchmark, and none of it should be copied into a strategy deck without the word "directional" attached. The durable takeaways are architectural: render for non-browser readers, own the third-party surfaces that describe you, instrument what you can't log, and keep untrusted content untrusted in both directions.
Sources
- AIVisib, "We tracked 287 AI answers about AI-visibility tools. Here are the sources ChatGPT, Gemini, Perplexity and Claude actually cite" — https://dev.to/aivisib/we-tracked-287-ai-answers-about-ai-visibility-tools-here-are-the-sources-chatgpt-gemini-1mha (primary source; full citation table, prompt set and per-assistant breakdown are in the original)
- RFC 9309, Robots Exclusion Protocol — the normative reference for crawler access decisions referenced above
- The
llms.txtproposal (informal community spec, not a standard) — relevant if you are evaluating a machine-readable summary surface for your site



