AI Answers by Buyer Intent: Learn vs Consider vs Purchase

AI answers change shape with buyer intent: questions that compare options name brands about twice as often as questions that ask how something works. Across 280 unbranded buyer answers from ChatGPT, Gemini, Perplexity and Claude, a tracked competitor was named in 52.5% of consider-stage answers and 27.5% of learn-stage answers. Our own brand was named in 0 of 80 learn answers.

So a single mention rate hides three different games. By the end of this post you'll know how learn, consider and purchase answers differ in brands named, sources cited and length. You'll also see which stage your prompt set under-weights and what to change on your site for each. A script splits your own answers by stage.

Data used: 35 unbranded buyer prompts (10 learn, 15 consider, 10 purchase) × ChatGPT, Gemini, Perplexity and Claude × 2 runs on 2026-10-20 (280 answers, web search on), collected by BugViso's AI Visibility Tracker for bugviso.com (website-audit software) against five anonymised competitors. Intent labels were set when the prompt set was drafted and frozen before the runs.

The Three Buyer Stages in a Prompt Set

Each buyer prompt is labelled learn, consider or purchase by what the asker wants next. The labels follow the classic buyer decision process, squeezed into the three stages where the question changes shape:

BugViso's default mix for the unbranded part of a prompt set is about 30% learn, 40% consider and 30% purchase. Our set had 10, 15 and 10. How you write each kind is covered in buyer prompts for AI search; this post is about what comes back.

How Answers Differ by Stage

Here's the stage split from the script further down, run on our 280 answers:

"List pages" means citations whose URL path contains best, top-N, alternative, vs, compare or review. The engines also ran more searches for later stages: 1.5 per answer on learn prompts, 2.0 on consider and purchase. Those counts come from the queries each API returns with its answer; Gemini, for example, lists them in the metadata of grounding with Google Search.

Three patterns, one per stage.

Learn answers explain, and name the brands that own the category

Learn answers are the longest and name the fewest brands. The median learn answer ran 2,599 characters, half again as long as a purchase answer. Most of it was explanation: what an audit checks, how Core Web Vitals work, what llms.txt is.

When a learn answer did name a tool, it was a category leader used as an example. Competitor A was named first in 11 of the 22 learn answers that named anyone. Four of our 10 learn prompts produced no tracked brand at all across 8 answers each: the questions about crawlers blocked by a CDN, Core Web Vitals, PageSpeed Insights differences and accessibility checkers.

Learn answers also leaned on reference sources: 20 of the 24 citations typed "reference" in the whole dataset were in learn answers.

Consider answers build shortlists

Consider answers name the most brands and cite the most sources. Half of them named a tracked competitor, and they averaged 7.3 citations each. The engines were building a shortlist, and shortlists come from list pages: 17.0% of consider citations went to "best", "top" or "alternatives" URLs.

The first-named brand in consider answers was usually the category leader: Competitor A 28 times, Competitor E 16 times, our brand 9 times. Our post on listicles in AI recommendations shows how much those list pages decide who makes the cut.

Purchase answers fit a specific need, and that's where small brands win

Purchase answers name fewer brands, but they're where a specialist gets named. Our brand's best stage was purchase: 10 of 80 answers (12.5%), and we were the first-named brand in 9 of them, more than any competitor.

The reason is in the prompts. Purchase questions carry a constraint: pay per report, more than 300 scans a month, scheduled re-scans per client. A narrow constraint matches a narrow product, and the engine reads the product's own page to check it. That's why our site was cited in 18.8% of purchase answers and none of the learn ones.

Each Engine by Stage

Stage effects held on every engine, but the size differed. Answers naming any tracked brand, out of 20 learn, 30 consider and 20 purchase answers per engine:

Gemini named brands in 13 of 20 purchase answers, far more than the others; it tends to answer "which should I buy" with a list. Claude and Gemini named brands even on learn prompts, as examples. ChatGPT and Perplexity mostly kept learn answers brand-free.

Each engine-stage cell holds 20 or 30 answers. That's enough to see the direction, not enough to rank engines within a stage. BugViso flags any segment under 20 answers as low confidence for this reason.

Why the Stage Mix Changes Your Score

Your headline mention rate depends on how many learn prompts are in the set. Because our brand scored 0% on learn, adding learn prompts would pull our overall rate down, and swapping them for purchase prompts would push it up. Neither changes how engines treat the brand.

Using our per-stage rates (0.0%, 9.2%, 12.5%), here's what the same answers would produce under different mixes:

The weighted rates are arithmetic on the stage rates above, not new runs. The point is the spread: almost a factor of two, from the mix alone. Freeze the mix with the prompt set, report stage rates beside the headline, and never compare headlines across sets with different mixes. The same logic applies to branded prompts, which we covered in branded vs unbranded prompts.

What to Fix for Each Stage

Each stage responds to a different kind of page. Match the work to the stage where you're missing.

1. Learn: publish the explanation engines quote. Learn answers are long and cite reference and educational pages. A clear explainer that defines the problem, with your product as one worked example rather than the subject, is the page that gets cited. Google's guidance on helpful, people-first content applies directly: write it for the person asking.
2. Consider: get onto the lists engines read. Shortlists come from list pages and competitors' own comparison posts. Find the "best X" pages cited in your consider answers and earn a place on them, with a one-line description of what you're best for.
3. Purchase: make your constraints explicit on your own pages. Purchase answers check a specific need against product pages. State prices, quotas, limits and plan features as plain text on crawlable pages, so an engine checking "more than 300 scans a month" finds the answer on your site.

Our own data shows the order to work in. We had a purchase-stage presence and no learn-stage presence. The cheapest gain was making purchase-stage facts clearer; the hardest, most valuable gain is becoming the example engines use on learn questions.

Split Your Own Answers by Stage

This script reads an answer export with an intent column and prints, per stage, the share of answers naming your brand and any listed competitor, brands per answer, citations per answer, answers citing your domain, the share of citations going to list-style pages, and median answer length. Standard library only.

#!/usr/bin/env python3
"""AI answers by buyer stage (learn / consider / purchase): who gets named, how many sources
are cited, and how often your own site is one of them.

Usage: python3 stage_report.py answers.csv --brand Acme --domain acme.com --competitor Globex ...
answers.csv columns: engine, intent (learn/consider/purchase), answer, cited_urls (space-separated), branded (1/0).
"""
import argparse, csv, re
from collections import defaultdict
from statistics import median
from urllib.parse import urlparse

LIST_PAGE = re.compile(r"(best|top-\d|alternative|-vs-|compar|review)", re.I)

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("csv"); ap.add_argument("--brand", required=True); ap.add_argument("--domain", required=True)
    ap.add_argument("--competitor", action="append", default=[])
    a = ap.parse_args()
    rx = lambda n: re.compile(r"(?<![\w-])" + re.escape(n) + r"(?![\w-])", re.I)
    you, rivals = rx(a.brand), [rx(n) for n in a.competitor]
    host = lambda u: (urlparse(u).hostname or "").lower().removeprefix("www.")
    st = defaultdict(lambda: defaultdict(list))
    for r in csv.DictReader(open(a.csv, newline="", encoding="utf-8")):
        if r.get("branded") == "1":
            continue
        s, urls, t = st[r["intent"]], r["cited_urls"].split(), r["answer"]
        s["you"].append(bool(you.search(t)))
        s["rival"].append(any(x.search(t) for x in rivals))
        s["brands"].append(bool(you.search(t)) + sum(bool(x.search(t)) for x in rivals))
        s["cites"].append(len(urls))
        s["own"].append(any(host(u) == a.domain or host(u).endswith("." + a.domain) for u in urls))
        s["lists"].append(sum(bool(LIST_PAGE.search(urlparse(u).path)) for u in urls))
        s["len"].append(len(t))
    pct = lambda v: f"{100 * sum(v) / len(v):5.1f}%"
    print(f"{'stage':<10}{'answers':>8}{'you':>8}{'rivals':>8}{'brands/ans':>11}{'cites/ans':>10}"
          f"{'own site':>10}{'list pages':>11}{'median len':>11}")
    for k in ("learn", "consider", "purchase"):
        s = st.get(k)
        if not s:
            continue
        n = len(s["you"])
        print(f"{k:<10}{n:>8}{pct(s['you']):>8}{pct(s['rival']):>8}{sum(s['brands']) / n:>11.2f}"
              f"{sum(s['cites']) / n:>10.1f}{pct(s['own']):>10}"
              f"{100 * sum(s['lists']) / max(1, sum(s['cites'])):>10.1f}%{median(s['len']):>11.0f}")
    print("\nyou/rivals = share of answers naming the brand / any listed competitor;"
          " own site = answers citing your domain; list pages = share of citations to best/top/vs/alternatives/review URLs.")

if __name__ == "__main__":
    main()

python3 stage_report.py answers.csv --brand BugViso --domain bugviso.com \
  --competitor "Competitor A" --competitor "Competitor B" --competitor "Competitor C" \
  --competitor "Competitor D" --competitor "Competitor E"

On our export it prints the stage table above. str.removeprefix needs Python 3.9 or later. If your export has no intent column, label prompts first: learn questions ask "what" or "how", consider questions ask for options, and purchase questions add a constraint and ask which to pick.

How BugViso Segments AI Answers by Buyer Intent

BugViso's AI Visibility Tracker labels every prompt learn, consider or purchase when it drafts the set from your site, and you can change the label when you review the prompts. Every run then computes the full leaderboard per intent stage, as well as per engine and per topic. Each segment shows mention rate, share of voice, position and citations for your brand and every tracked competitor, and any segment with fewer than 20 answers is flagged low confidence.

The report lists your strongest and weakest confident segments, so a 0% learn stage shows up as a gap rather than disappearing into the average. The prompt table gives every question's stage beside the engines that named you and who appeared instead. Intent segments are part of the AI visibility tracker report.

Stage Analysis Mistakes

Changing the mix between reports. A move from 30% to 50% learn prompts can drop the headline by a third without any engine changing its answers. Keep the mix frozen with the prompt version.

Calling learn prompts wasted. A 0% learn stage is a finding: engines don't use you as the category example. It's often the slowest gap to close and the most valuable.

Writing purchase prompts that only you can answer. "Which tool has a 60-day scan rollover" names one product by design. Purchase prompts should carry real buyer constraints, not your feature list.

Ranking engines within one stage. Twenty answers per engine and stage is too few. Use the stage split to choose work, not to grade engines.

Frequently Asked Questions

Do AI answers differ by search intent?

Yes. In our 280 buyer answers, consider-stage questions named a tracked competitor in 52.5% of answers, learn-stage questions in 27.5%. Learn answers were longer, cited fewer sources and rarely named small brands; purchase answers named fewer brands but checked specific needs against product pages.

Which buyer stage should I track in AI search?

All three, labelled and reported separately. Consider prompts show whether you make the shortlist, purchase prompts whether you win specific needs, and learn prompts whether engines use you as the category example. A 30/40/30 learn/consider/purchase mix is a reasonable default.

Why does ChatGPT not mention my brand on informational questions?

Informational answers explain the topic and name few tools, usually category leaders as examples. In our data, ChatGPT named a tracked brand in only 3 of 20 learn answers. Being cited there needs explainer content engines quote, not product pages.

How do I get recommended on purchase-intent AI queries?

State your prices, limits and plan features as plain text on crawlable pages, so an engine checking a buyer's constraint finds the answer on your site. Our site was cited in 18.8% of purchase-stage answers, mostly pricing and feature pages.

Is it fair to compare AI visibility across prompt sets?

Only if the stage mix and branded share are the same. The same per-stage rates gave us a blended 5.3% or 9.9% depending on the mix, with no change in the answers.

Read the Stage Split Before the Headline

One mention rate averages three different questions; split it by buyer stage, keep the mix frozen, and fix the stage where you're missing with the kind of page that stage cites. BugViso's AI visibility tracking reports every run by intent stage, so the gap is visible from the first report.