Listicles and AI Recommendations: The 'Best X Tools' Problem

AI engines build many of their brand recommendations from "best X tools" listicles, so a brand that isn't on the lists rarely gets recommended. We fetched the 185 independent list pages that ChatGPT, Gemini, Perplexity and Claude cited for our buyer questions. Our brand appeared on none of them, while each of five established competitors appeared on 32–64%. When an answer cited lists that left a competitor out, it named that competitor 4% of the time or less.

This study measures how much engines lean on listicles, which engines lean hardest, and how closely the brands on the list match the brands in the answer. It ends with a script that finds the lists cited for your own prompts and checks which of them leave you out.

Data used: 35 unbranded buyer prompts × ChatGPT, Gemini, Perplexity and Claude × 2 runs on 2026-10-20 (280 answers, 1,776 citations), collected by BugViso's AI Visibility Tracker for bugviso.com (website-audit software) against five anonymised competitors, A–E. List pages were identified by URL and title (best, top N, alternatives, vs, comparison) and fetched on 2026-10-21 with a plain HTTP GET, no JavaScript. Third-party sites aren't named.

Key Findings

1. One in five citations is a list page, and two in five on Claude

The 382 list citations pointed to 226 URLs on 184 domains. Thirty of those URLs were cited in three or more answers, and the most-cited one appeared in 13. A small set of roundups does much of the work.

ChatGPT is the outlier. It cited a list page twice in 70 answers and leaned on vendor sites and documentation instead. On ChatGPT, list placement matters least.

2. Lists show up when buyers compare

Learn-stage answers explain concepts from guides and documentation. Once the buyer starts comparing, engines reach for roundups. That's the stage where a shortlist forms.

3. Answers that cite lists name more brands

Engines that read a list come back with names from it. Without a list, they more often describe what to look for and leave the choice to the buyer.

4. The lists left our brand out completely

We fetched all 226 cited list URLs. 210 returned 200, 11 blocked us with 403, and 5 failed. 201 pages had enough text to read without JavaScript. Then we checked which tracked brands each page names.

"Independent" excludes lists published by any of the six tracked brands. Our 4 appearances were our own blog posts. The citation-weighted column weights each list by how many answers cited it, and the gap there is just as wide.

5. The answer follows the list

For each competitor, we split the answers that cited at least one readable list into two groups: answers whose cited lists include that competitor, and answers whose lists don't.

Being on a cited list doesn't guarantee a mention. Engines pick a few names from each list. But being off every cited list almost guarantees no mention in that answer. Competitor B was named zero times in 30 answers whose lists left it out, despite being one of the two most-named brands overall.

6. Vendors write lists too

Of the 382 list citations, 31 went to lists published by tracked competitors on their own blogs: 19 to Competitor B's and 11 to Competitor E's. These are vendor-written roundups that include their author. Engines cited them like any other roundup. Our own comparison-style posts were cited 6 times.

Methodology

• List detection. A cited URL counts as a list page when its path or title contains "best", "top" (with or without a number), "alternatives", "vs"/"versus" or "compar…", or a number followed by "best"/"top". URL paths alone find 261 of the 382 citations; titles add the rest.
• Fetching. One plain GET per URL with a desktop user agent, 4 at a time with a pause between requests, on 2026-10-21. No JavaScript was executed. Pages under 1,500 characters of text were treated as unreadable (usually client-rendered pages).
• Brand detection. Case-insensitive name matching at word edges, including the domain form ("brandname" in a URL-like spelling).
• Answer side. The tracker's stored mentions for each answer, which use the same name and alias matching, checked against 24 hand-labelled answers.
• Time gap. Answers were collected on 2026-10-20 and pages fetched a day later. Lists change, so a few pages may differ from what the engine read.

How to Get Into AI Recommendations Built from Listicles

Ordered by how many of our missed answers each action addresses:

1. Get onto the specific lists engines cite for your prompts. Not "lists in general": the 20–30 URLs that keep appearing in your answers. In our data, 30 URLs covered most of the list citations. Pitch each author with a short, factual case: what you do, for whom, at what price, and one verifiable proof point.
2. Prioritise lists cited by Claude and Gemini. They lean on lists hardest (40.5% and 21.5% of citations) and link the vendors they name least. Claude decides for itself when and what to search (Anthropic's web search tool docs), and in our data a third of its queries asked for "best", "vs" or "alternatives". Our Claude analysis shows how its search queries go looking for roundups.
3. Publish an honest comparison of your own. Vendor-written roundups were cited 31 times for competitors. Include competitors fairly, state your methodology and a date, and mark the list up with schema.org ItemList if it fits. A self-serving list that ranks only you won't hold up with readers. Google's helpful content guidance asks whether content provides "original information, reporting, research, or analysis", and a real comparison can.
4. Make your own pages quotable for the engines that read vendors. ChatGPT and Perplexity named us through our own pages, not through lists. Keep that path open while list placements take time. See AI citations to your website.
5. Re-check monthly. Roundups are updated, re-ranked and replaced. A placement you earned in March can be gone by June.

💡 Outreach rule: lead with what makes you a fit for that list's reader ("pay-per-report, no subscription, for solo consultants"), not with a request to be added. Authors update lists when you make their article better.

The Script: Which Cited Lists Leave You Out

#!/usr/bin/env python3
"""Find the "best X tools" pages AI engines cite for your buyer questions, fetch each one and
check which brands it lists, so you know which lists leave you out.

Usage: python3 listicle_check.py answers.csv --brand Acme --competitor Globex --competitor Initech
answers.csv columns: engine, answer, cited_urls (space-separated), branded (1/0; branded rows are skipped).
Plain GET, no JavaScript, 1 request per second. Pages that block bots or render client-side are skipped.
"""
import argparse, csv, html, re, time, urllib.request
from collections import Counter
from urllib.parse import urlparse

LIST = re.compile(r"\bbest\b|\btop[ -]?\d+|\btop\b|alternatives?|\bvs\b|versus|compar|\b\d+\s+(?:best|top)\b", re.I)

def is_listicle(url):
    return bool(LIST.search(urlparse(url).path.replace("-", " ").replace("_", " ").replace("/", " ")))

def page_text(url):
    req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0 (listicle check)"})
    with urllib.request.urlopen(req, timeout=20) as r:
        raw = r.read(3_000_000).decode("utf-8", "replace")
    raw = re.sub(r"(?is)<(script|style|noscript)\b.*?</\1>", " ", raw)
    return html.unescape(re.sub(r"<[^>]+>", " ", raw))

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("csv"); ap.add_argument("--brand", required=True)
    ap.add_argument("--competitor", action="append", default=[]); ap.add_argument("--top", type=int, default=30)
    a = ap.parse_args()
    names = [a.brand, *a.competitor]
    rx = {n: re.compile(r"(?<![\w-])" + re.escape(n) + r"(?![\w-])", re.I) for n in names}
    cited, total = Counter(), 0
    for r in csv.DictReader(open(a.csv, newline="", encoding="utf-8")):
        if r.get("branded") == "1":
            continue
        urls = set(r["cited_urls"].split())
        total += len(urls)
        cited.update(u for u in urls if is_listicle(u))
    print(f"{sum(cited.values())} of {total} citations ({100 * sum(cited.values()) / max(1, total):.1f}%) "
          f"point to {len(cited)} list-style pages. Checking the top {a.top}...\n")
    lists_on = Counter(); read = 0; missing = []
    for url, n in cited.most_common(a.top):
        try:
            text = page_text(url)
        except Exception as e:
            print(f"  skip ({type(e).__name__}) {url}"); continue
        if len(text.split()) < 300:
            print(f"  skip (too little text without JS) {url}"); continue
        read += 1
        found = [b for b in names if rx[b].search(text)]
        lists_on.update(found)
        if a.brand not in found:
            missing.append((n, url, found))
        time.sleep(1)
    print(f"\nlists read: {read}")
    for b in names:
        print(f"  {b:<16} on {lists_on[b]:>3} of {read}")
    print(f"\nCited lists that leave {a.brand} out (citations, URL, brands they do list):")
    for n, url, found in missing:
        print(f"  {n:>3}  {url}\n       lists: {', '.join(found) or 'none of the tracked brands'}")

if __name__ == "__main__":
    main()

python3 listicle_check.py answers.csv --brand "Acme" --competitor "Globex" --competitor "Initech" --top 30

The script matches URL paths only, because exports rarely carry page titles, so it finds fewer lists than the study did (261 citations instead of 382 on our data). On our top 12 lists it reported our brand on 0 of 12 and the most-listed competitors on 11 or 12 of 12. Its output is the outreach list: every cited roundup that leaves you out, sorted by how many answers cited it, with the brands it does include.

How BugViso Finds the Lists That Leave You Out

BugViso's AI Visibility Tracker records every citation in every answer and computes source gaps: domains cited in answers that name a competitor but not you, ranked by how many answers they appear in, with the engines that cited them and the cited URLs. Roundups, comparison pages and directories surface there first, because they're what Gemini and Claude cite when they name rivals. The method behind the gap list is in our AI citation gap analysis.

Source gaps feed the "what to do" plan. The item "Get onto the pages the engines cite instead of you" lists the top gap pages and walks through the steps. Check why rivals are listed (a roundup, a comparison, a directory entry). Pitch the author with a factual case. Claim a listing where the page is a directory. Then watch for your brand on those domains in the next weekly change. The plan can draft the outreach email, and it can draft a comparison page against your top rival. Both are drafts for you to check and send yourself. The gap view is shown on the AI visibility tracker page.

Limitations

One category. Website-audit software has an established set of roundups. Newer categories may have fewer lists, and engines there may lean on vendor pages instead.

Correlation, partly. Answers to generic category questions both cite lists and name incumbents. The near-zero mention rate when lists omit a brand is strong evidence, but it doesn't prove the list caused the mention.

Static fetch. 25 of 226 pages couldn't be read without JavaScript or blocked automated requests. Their brand content is unknown.

Name matching. A list that mentions a brand anywhere, even in a "not included" note or a sidebar, counts as naming it. Read the shares as an upper bound on being recommended by the list. Our 0 of 185 has no such caveat.

Frequently Asked Questions

Do AI engines use listicles to recommend brands?

Yes, heavily on some engines. List pages were 21.5% of all unbranded citations in our data and 40.5% of Claude's. Answers that cited a list named a tracked brand 53% of the time, against 34% for answers that didn't cite one.

How do I get my brand into AI recommendations?

Find the specific list pages AI engines cite for your buyer questions and get onto them, publish a fair comparison of your own, and make your own pages answer buyer questions directly for the engines that read vendor sites.

Which AI engine relies most on "best of" lists?

Claude, in our data: 40.5% of its unbranded citations were list pages. Gemini (21.5%) and Perplexity (18.9%) followed. ChatGPT cited a list page only twice in 70 answers.

Do vendor-written "best tools" lists get cited by AI?

Yes. Lists published by two tracked competitors on their own blogs were cited 31 times. Engines treated them like independent roundups.

If I'm on a list, will AI recommend me?

Not always. Engines pick a few names from each list: competitors on the cited lists were named in 27–49% of those answers. But brands left off every cited list were almost never named, 0–6% of the time.

Get on the List Before You Optimise the Page

For the engines that recommend from roundups, the list is the gatekeeper and your own page comes second. Find the lists your buyers' questions pull in, earn a fair place on them, and track which ones move, which is what BugViso's AI visibility tracking surfaces as source gaps after every run.