Shopify product descriptions for AI shopping agents: the six signals ChatGPT, Perplexity, and Google AI Mode extract

Why product descriptions matter more now than in the SEO era

For the past decade, conventional e-commerce SEO advice pushed merchants toward shorter, keyword-dense product pages. A/B tests consistently showed that shoppers didn't read long descriptions. The advice became: put your keywords in the title and meta description, keep the body copy short, and let structured data carry the catalog signals.

That logic was correct for traditional search engines, which primarily ranked products by keyword match and PageRank signals. It is wrong for AI shopping agents.

When a shopper asks ChatGPT "find me a lightweight running shoe under $120 that works for wide feet," ChatGPT doesn't return a ranked list of keyword-matching URLs. It generates a recommendation — a natural language response that may quote specific product attributes, contrast options, and explain why a particular product fits the shopper's query. To generate that recommendation, the agent needs rich source material. Your product description is that material.

Structured data (Product JSON-LD) handles price, availability, GTIN, and review scores. But the qualitative fit signals — why this shoe works for wide feet, what materials make it lightweight, which training styles it's designed for — come from the description. If the description doesn't contain them, the agent either skips your product or invents them (hallucinating specifications is a known failure mode for LLM-based shopping agents when product data is thin).

How AI shopping agents read product descriptions

AI shopping agents access your product descriptions through three pathways, each with different implications for how they use the content:

1. Direct page crawl

GPTBot (ChatGPT), PerplexityBot, Google-Extended, and ClaudeBot all crawl your product pages directly. When they render your product page, they extract the text content from the body_html field that Shopify outputs inside the product description container (.product-description or [data-product-description] in most themes). This is the full HTML description — including any formatting you've applied in the Shopify product editor.

What they don't always do: execute JavaScript that loads description content after the initial page render. If you're using a third-party app that injects enriched product content via client-side JS, that content may be invisible to crawlers. The description that matters is what appears in the server-rendered HTML response.

2. /products.json feed ingest

ChatGPT Shopping's OAI-SearchBot and Perplexity's PerplexityBot both consume Shopify's /products.json endpoint as a bulk catalog ingest. This endpoint exposes the body_html field for every product. However, HTML tags are stripped during processing — the agent sees plain text, not formatted HTML. Bullet points created with <ul><li> survive as whitespace-separated text, but visual formatting cues are lost. The underlying word content is what matters.

3. Google Merchant Center / Shopping Graph

Google AI Mode's product knowledge panels draw from the Google Merchant Center Shopping Graph, which in turn is fed by your Google Shopping product feed. If you're using the Google & YouTube channel app or a third-party feed tool, the description field in your feed is typically sourced from the Shopify body_html field (HTML-stripped). Google's Shopping Graph enrichment process does additional processing — including entity extraction and cross-reference matching — but the raw description quality still anchors the signal strength.

The 150-word threshold and why it exists

There is no published minimum word count requirement from any AI shopping agent. But analysis of product visibility patterns shows a consistent inflection point around 150 words: products with descriptions below this threshold appear significantly less often in AI-generated shopping recommendations, even when their structured data (price, GTIN, AggregateRating) is correctly implemented.

The reason is probabilistic. AI recommendation models work by measuring semantic similarity between the shopper's query and the product content. A 30-word description — "Premium running shoes with breathable mesh upper and cushioned sole. Available in multiple colors." — matches almost any shoe query. It provides no differentiating signal. With hundreds of similarly vague products competing for the same query, the model has no basis for preferring yours over any other.

A 200-word description that includes material composition, intended use cases, fit characteristics, and comparison context gives the model enough signal to match the product to specific shopper intents — "wide width," "trail vs. road," "for marathon training," "lightweight for speed work." Each concrete attribute is an additional match vector.

Per-agent behavior: ChatGPT vs. Perplexity vs. Google AI Mode

Each AI shopping agent extracts different information from product descriptions and weights that information differently in its recommendation model.

The six description signals that determine AI visibility

Based on analysis of product visibility patterns across CatalogScan's scan database, six structural elements in product descriptions consistently separate products that appear in AI shopping recommendations from those that don't.

Common Shopify description problems that hurt AI visibility

Most description problems in Shopify stores fall into one of six categories. Each one reduces AI shopping visibility in a different way.

Problem 1: Marketing copy substituted for product information

The most common failure mode. Descriptions written to "convert" rather than to inform: "Experience the pinnacle of craftsmanship with our award-winning collection. Every detail has been carefully considered to bring you a product that exceeds your expectations." This copy contains no attributes, no use-case signals, no specifications — nothing an AI agent can extract to answer a shopper's question.

Problem 2: Shopify Magic defaults left in place

Shopify Magic, the AI writing assistant built into the product editor, generates short (40–80 word) generic descriptions when given minimal input. These descriptions consistently score low on the signal checklist: they're typically two sentences of marketing phrasing with no specific attributes. If you used Shopify Magic to generate descriptions and didn't rewrite them, your catalog likely has a systemic description quality problem.

Problem 3: HTML in the description that doesn't render as content

Some merchants paste in raw HTML, inline CSS, or embed code directly into the product description editor. When AI agents process the body_html field from /products.json, they receive this HTML as literal text — including tag names, attributes, and encoded characters. The effective word count drops dramatically once all the non-content markup is removed. A 500-character description field can have fewer than 80 words of actual product text.

# Check how much of your description is actually text vs. HTML markup
# Run this in your browser console on a product page:
const desc = document.querySelector('.product-description');
const text = desc ? desc.innerText.trim() : '';
console.log('Word count:', text.split(/\s+/).filter(Boolean).length);
console.log('HTML length:', document.querySelector('[data-product-description]')?.innerHTML?.length || 0);

Problem 4: Variant-level attributes missing from the main description

Shopify's product structure separates product-level attributes (title, description, vendor) from variant-level attributes (size, color, SKU, weight, price). AI agents consuming /products.json do get variant data — but the description field is product-level only. If your description says "available in three sizes" without specifying what those sizes are, and the weight or dimensions differ by variant, that per-variant spec is either buried in the variant object or missing entirely from the text the agent reads.

The fix: add a brief specification section to the product description that enumerates variant-level differences — "Available in S (255g), M (285g), L (310g)" — so agents can match queries like "the lightweight version" or "the XL size."

Problem 5: Duplicate descriptions across product variants or similar products

Using the same boilerplate description across multiple products (different colors of the same item, different SKUs in a product line) creates a content duplication problem. AI agents normalize their content index and down-rank duplicated text. More practically: if 12 products share the same 80-word description, none of them stand out in the semantic similarity matching that determines recommendations. Each product needs description text that's differentiated enough to match distinct queries.

Problem 6: No query-matching language for long-tail intents

Shoppers query AI agents in natural language, often with very specific constraints: "water bottle that fits in a car cup holder and keeps drinks cold for 12 hours," "yoga mat thick enough for joint pain that doesn't slip on hardwood." These are multi-constraint queries. A description that mentions "12-hour insulation" and "2.75 inch diameter" matches the first query. A description that says "thick, non-slip" without measurements matches neither query specifically.

The JSON-LD description connection

Your Product JSON-LD schema includes a description property. Most Shopify themes that auto-generate structured data populate this field from the same body_html source as the visible page description — which means whatever problems exist in your HTML description also exist in your structured data description.

There's an additional constraint in JSON-LD: the description property should be plain text, not HTML. Some auto-generated Product schemas pass the raw HTML string into the JSON-LD, which creates invalid structured data (Rich Results Test will flag this as an HTML parsing error).

The correct Liquid pattern for a clean, plain-text description in JSON-LD:

{%- liquid
  assign desc_text = product.description | strip_html | strip_newlines | truncatewords: 500
-%}
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": {{ product.title | json }},
  "description": {{ desc_text | json }},
  ...
}
</script>

The strip_html filter removes all HTML tags. strip_newlines flattens the text to a single line, which prevents JSON parsing errors from literal newlines inside a string value. truncatewords: 500 caps the field at 500 words — past that, the JSON-LD size starts affecting page weight without proportional benefit for structured data.

Also important: the description in the Product schema is different from the description of an Offer (which is used for condition/availability notes) and from the meta description tag (which is what Google shows in standard blue-link search results). These three description fields serve different audiences and should be maintained separately.

Writing descriptions that work for all three agents

The description structure that scores highest across ChatGPT, Perplexity, and Google AI Mode follows a consistent five-part format. This isn't a template to paste verbatim — it's a checklist of the elements to hit, in approximately this order:

1. Lead with the specific USP. First sentence, 15–25 words. State the one thing that's true about this product that isn't generically true of every product in its category. This anchors the agent's understanding before it reads the rest.
2. Name the primary use case and user type. One or two sentences. Who is this for, in what context, doing what activity? "Built for professional baristas pulling 200+ shots per day" is infinitely more useful to an AI agent than "perfect for coffee lovers."
3. List the key specifications with numbers. The most important measurable attributes. For physical products: weight, dimensions, materials, capacity. For consumables: concentration, ingredients, size/volume. For software: limits, integrations, supported platforms. Numbers are the most extractable unit in product descriptions — AI agents quote them precisely.
4. Address a specific constraint or problem. One sentence, explicitly stating what kind of shopper problem this product solves. Mirrors the structure of high-intent queries ("for people who need X," "if you have Y problem").
5. Brief comparison context. One or two sentences positioning against the category norm or a well-known alternative. This activates comparison query matching. Be factual, not disparaging.

This structure produces a description in the 150–250 word range for most products. For high-ticket, complex, or technical products, adding a "what's in the box" section and an FAQ block (3–5 questions) extends coverage of long-tail queries without diluting the core content.

Before / after: a real description rewrite

Here's a representative example of a Shopify product description rewritten using the framework above. The "before" version is a common real-world pattern — not a strawman.

Product: Stainless steel insulated water bottle, 32 oz

The "after" version hits all six signals: specific USP with quantified claim, named use case and user type, exact materials with grades, constraint language ("for people who've had problems with"), comparison context (diameter, competitor fit), and quantified specs throughout. At 218 words, it comfortably exceeds the 150-word threshold and gives AI agents multiple distinct match vectors for different query types.

Auditing your catalog with CatalogScan

Running a manual description audit across a large product catalog is impractical — a 500-product Shopify store can take days to review and rewrite by hand. CatalogScan's description signal check identifies which products fall below the length threshold, which have high HTML-to-text ratios, and which are missing key attribute categories (material, specification, use case) — so you can prioritize rewrites where they'll have the most impact on AI shopping visibility.

The scan also correlates description quality against the other 12 visibility signals (GTIN coverage, AggregateRating implementation, robots.txt access gates, canonical URL discipline) to show where description problems compound with other issues — the cases where fixing the description alone won't fully unlock visibility because a structured data gap is blocking the same product.

FAQ

Does the Shopify product meta description affect AI shopping agents?

The meta description tag (<meta name="description">) is primarily used by standard search engines for blue-link snippets. AI shopping agents consuming /products.json don't read the meta description — they read the body_html field. Google AI Mode crawlers read both, but the product body description is weighted higher for Shopping Graph content. Write your meta description for search engine CTR; write your product description for AI agent recommendations. They're separate optimization targets.

Should I write one long description or use bullet points?

Both formats work for AI agents — the underlying text is what matters, not the HTML formatting. However, AI agents processing /products.json receive your description as HTML-stripped plain text, so bullet points become whitespace-separated text fragments. If your specifications are in a bullet list, make sure each bullet is self-contained ("Weight: 350g (12.3 oz)") rather than dependent on a preceding sentence for context. Prose paragraphs communicate better when the HTML is stripped; structured data (JSON-LD specifications property) is the better home for pure tabular data.

How often should I update product descriptions?

AI agents re-crawl your product pages periodically — the interval is product-category and traffic-dependent, but high-selling products typically get crawled every 2–4 weeks by major crawlers. If you add a new use case, update a specification, or want to add comparison language after seeing competitor data, updates take effect within one to two crawl cycles. The bigger leverage is getting all products above the 150-word threshold before optimizing individual descriptions further — batch improvement across the catalog beats perfecting a handful of top products.

Will AI-optimized descriptions hurt my conversion rate on the product page?

Not if you write them well. The attributes that help AI agents are also the attributes shoppers read when evaluating a purchase — specific specs, clear use cases, honest comparison context. The descriptions that hurt conversion rates are the ones that obscure product attributes behind marketing language. Rewriting toward specificity tends to improve both AI visibility and human conversion rate simultaneously. The two goals are more aligned than the conventional "short copy for conversion" wisdom suggests.

My descriptions are auto-generated by an AI tool — is that a problem?

It depends on the input quality. AI description generators (including Shopify Magic) produce generic output when given generic input. If you're feeding them just a product title and a few tags, you'll get a description that looks like every other AI-generated description in the category — and it will score poorly on the six signals above. AI generation tools work well when you give them specific input: exact materials, numeric specifications, known use cases, comparison context. The tool's job is to turn that information into readable prose; your job is to supply the information the tool needs.