Ecommerce product pages have traditionally been written for two audiences: humans and search engines.
Now there is a third one that is starting to matter more, but there are still no clear guidelines on how to write for it. I’m talking about large language models (LLMs).
These systems don’t just index content. They interpret it, summarise it, and increasingly use it to answer questions or support decisions.
That raises a practical question:
Does the way we structure product pages affect how LLMs understand them?
More specifically, I wanted to test:
- Does cleaner structure improve interpretation?
- Does HTML markup matter?
- Does “AI-friendly” wording actually change anything?
Instead of speculating, I ran a controlled experiment.
Hypotheses
The test was built around three simple hypotheses.
1. Structure matters
Structured content should improve clarity and completeness compared to typical paragraph-heavy ecommerce pages.
2. Explicit context matters
Adding clear semantic framing (what the product is, what it does, and when to use it) should improve understanding of use cases and constraints.
3. HTML may add signal
HTML structure might help models interpret content more effectively than plain text.
Methodology
The experiment uses a single product as a controlled base. I used the WIKA A-10 pressure transmitter and its datasheet as the source of truth, then created three versions of the same product page.
- Version A: Typical ecommerce content (paragraph-heavy, mixed information)
- Version B: Structured content (sections, bullet points, separated specs)
- Version C: Structured + explicit context (clear definitions and relationships)
Each version was tested in plain text and simple HTML with headings, lists but no styling.
This produced six inputs:
- A_text, A_html
- B_text, B_html
- C_text, C_html
These were tested across three models:
Using four prompts:
- Product summary
- Technical specification extraction
- Use cases and constraints
- Decision-making information
Outputs were evaluated across four dimensions with low, medium, high (L, M, H) ratings.
- Accuracy
- Completeness
- Clarity
- Constraint awareness
All inputs and outputs are uploaded to GitHub and accessible publicly.
Key Findings
1. Structure consistently improves clarity
Across models, structured versions (B and C) produced clearer and more organised outputs than the typical ecommerce version (A).
This effect was strongest in Google and Claude, where A often struggled to produce well-structured answers.
Content organisation directly affects how LLMs structure their responses.
2. Explicit context improves reasoning, not just formatting
Version C did not just look cleaner. It improved how models handled reasoning, especially around use cases, limitations, and conditional behaviour.
Models using this version were more likely to correctly identify constraints such as configuration dependency and operating limits.
LLMs do not reliably infer relationships. They perform better when those relationships are explicitly stated.
3. HTML alone has limited impact
Adding HTML structure produced mixed results. In some cases, it slightly improved clarity. In others, it had no effect or even performed worse than plain text.
There was no consistent pattern showing that HTML alone improves interpretation.
Markup does not compensate for poor content structure. The organisation of the content itself matters more.
4. Model sensitivity varies significantly
ChatGPT performed strongly across almost all versions, with relatively small differences between A, B, and C.
In contrast, Google and Claude were much more sensitive to structure. A versions often performed poorly, while B and C showed clear improvements.
More capable models compensate for weak content. Less capable ones depend heavily on structure.
5. Extraction tasks are easier than interpretation
When extracting technical specifications (Prompt 2), all models performed well. Even messy content (A) produced strong results.
However, interpretation tasks such as summaries, use cases, and decision-making showed much larger variation and were strongly affected by structure and context.
LLMs are good at extracting facts. They are less reliable at interpreting poorly structured content.
6. Constraints are the hardest dimension
Constraint awareness showed the most variability across all outputs. This includes things like operating limits, configuration dependencies, and conditional behaviour.
It was often missed in A, partially presented in B and strongest in C
If constraints matter, they need to be explicitly written. Models rarely surface them reliably from implicit content.
7. Completeness remains inconsistent
Even with structured content, completeness varied. Some outputs missed key details, while others prioritised certain aspects over others.
This was not strictly tied to structure.
LLMs do not aim to extract everything. They prioritise what they consider important.
8. Weak structure can introduce noise
In some cases, HTML versions of poorly structured content (A_html) performed worse than plain text.
Instead of helping, markup appeared to fragment already unclear information.
Structure needs to be meaningful. Adding HTML to messy content does not improve interpretation.
9. The gap between worst and best case is large
The difference between A_text (typical ecommerce) and C_html (structured + explicit + HTML) was significant across multiple dimensions, especially clarity and constraint awareness.
In the example above, Claude is given both versions of the same content. The difference is not subtle.
- In the structured version (C_html), the model clearly identifies ratiometric signals as a distinct concept, rather than leaving it embedded in a list.
- It also separates process connection details from sealing options, instead of treating them as a single block of information.
- Performance-related elements such as signal noise, drift, and response time are surfaced as independent, meaningful attributes, rather than being buried in general description.
In contrast, the A_text version keeps these elements mixed together. The information is technically present, but not clearly interpreted or prioritised.
And this is the key point: The difference is not in the data, but in how the model is able to structure and interpret it.
Typical product pages often contain the right information, but in a format that makes interpretation harder. When structure and context are improved, the model does not just repeat the content. It reorganises it into something closer to a usable representation.
Typical product pages are far from optimal for LLM interpretation.
10. Some tasks plateau quickly
For broader prompts like “what matters for choosing this product”, all versions performed similarly and differences were minimal.
Not all tasks require deep understanding. Some prompts produce acceptable answers regardless of structure.
11. Structure alone is not enough
Version B improved clarity but did not consistently improve reasoning.
Version C, which adds explicit context, showed stronger results across constraints, interpretation, and consistency.
Organisation helps. Explicit meaning helps more.
12. Clear structure can trigger enrichment behaviour
In one case (C_html with ChatGPT), the model introduced references not present in the original content by browsing externally.
This behaviour did not appear in other versions.
A likely explanation is that the product became easier to recognise, allowing the model to connect it to prior knowledge.
At a certain clarity threshold, models may move from extraction to enrichment.
Unexpected Behaviours
Multilingual mixing (Arabic)
In some structured outputs (Version B), ChatGPT mixed English with Arabic terms, despite no Arabic content in the source.
This appeared at word level, with a single translated term inside an otherwise English sentence.
This behaviour did not appear in A or C.
A likely explanation is that structured but ambiguous content triggered patterns similar to multilingual product data, leading to token-level language substitution.
This is not hallucination. The meaning remains correct, but the language becomes unstable.
Structure without clear semantic framing can introduce noise, not just clarity.
External referencing behaviour
In the structured + explicit HTML version (C_html), ChatGPT introduced references beyond the provided content.
This suggests that clearer structure and context improved entity recognition, allowing the model to rely on prior knowledge rather than only the input.
Well-structured content may enable models to connect with external knowledge, not just summarise what is present.
Practical Implications
For ecommerce and SEO, the implications are clear.
- Structure matters. Avoid long mixed paragraphs and separate product definition, features, specifications, use cases, and constraints.
- Relationships should be explicit. Do not assume the model will infer use cases or limitations. If something depends on configuration or has constraints, it needs to be written clearly.
- HTML alone is not enough. Semantic markup helps, but it does not replace clear organisation and meaning.
Finally, product pages should be designed for interpretation, not just indexing. The goal is not only to be crawled, but to be understood and summarised correctly.
Limitations
This is a small, controlled test. It uses a single product, a limited number of prompts, and manual evaluation.
I did not run statistical analysis, and although I tried to review outputs in a blind way, model differences were often recognisable.
The goal is not to prove a universal rule, but to observe patterns.
Conclusion
Product pages are no longer just documents to rank.
They are inputs to AI systems that interpret, summarise, and recommend products.
This experiment suggests that structure improves clarity, explicit context improves reasoning, and markup alone is not enough.
The gap between a typical ecommerce page and an AI-readable one is not subtle, and it is likely to matter more over time.
