Skip to content
← Back to Insights

Gemini Called My Website a Textbook Example. Here Is What It Took.

I asked Google Gemini whether my small-business website was ready for AI agents. It said textbook example. That verdict took months of invisible work, and you can run the same test tonight.

John Sambrook, TOC Jonah Certified ·
AI Small Business Practical Tips Architecture

TL;DR

On 23 August 2026 I asked Google Gemini whether common-sense.com was well prepared for AI agents and agentic commerce. It called the site “exceptionally well-prepared” and “a textbook example.” That verdict rests on months of work that no visitor ever sees, and I could not have done it without coding agents. You can run the same test on your own site tonight.

Checklist infographic titled What an AI agent reads first, with five rows each marked with an orange check: Structured data (JSON-LD), llms.txt, MCP pointer, robots.txt lets AI crawlers in, and Public API with OpenAPI. Footer reads: None of it is on the screen a human sees.

This morning I typed one question into Gemini: “Do a deep dive on common-sense.com and tell me if the website is well-prepared for AI agents and agentic commerce. Be concise.”

It came back with four findings and a conclusion. Machine-readable catalogs in JSON-LD, with exact pricing and return policies an agent can parse without scraping. Checkout triggers mapped as BuyAction pointing at real API endpoints, so an agent “can theoretically initiate a checkout autonomously.” A dedicated llms.txt file linked from the page head. A public API layer for service discovery, inquiry capture, and checkout. Its conclusion: “Common Sense Systems has intentionally built its digital infrastructure to allow AI agents to effortlessly discover, evaluate, and act upon its commercial offerings. It serves as a textbook example.”

Screenshot of Google Gemini's answer to the question: Do a deep dive on common-sense.com and tell me if the website is well-prepared for AI agents and agentic commerce. Gemini replies that the site is exceptionally well-prepared, lists machine-readable catalogs, agentic checkout triggers, dedicated LLM files, and a public API layer, and concludes it serves as a textbook example of how a modern business can optimize for agentic commerce.

I will take it. But “textbook example” makes it sound like I followed a recipe. There was no recipe. There was a lot of work, most of it invisible, and a lot of it was done by agents.

What an agent actually reads

A person landing on a website sees a design. An agent sees almost none of that. It looks for a short list of things, and the list is shorter than most web developers expect.

Structured data. A block of JSON-LD in the page head that says what this business is, where it is, what it sells, at what price, and what happens when you click buy. On my site every offer page carries a Product with an Offer, a price, availability, a return policy, and a BuyAction whose target is a real POST endpoint. That is the part Gemini called “highly detailed.”

A file called llms.txt. Plain text at the root of the site that tells a model what the site is for and where the authoritative data lives. Mine says, in so many words: trust the live page and the API for prices, trust this file for orientation, and never quote a price from a search snippet.

A pointer for agents. /.well-known/mcp.json tells an agent where the API is, which operations are public, and how checkout works. It also says what is not there, so nobody guesses.

Permission to crawl. robots.txt has to let the AI crawlers in. A surprising number of sites block GPTBot or ClaudeBot by accident, copied from a template, and then wonder why no assistant ever mentions them.

A public API with a contract. api.common-sense.com publishes an OpenAPI document. An agent can read it, call GET /v1/services, and get back the same offers, at the same prices, that the web pages show.

That is the whole list. None of it is on the screen a human sees.

What it took

A perfect result on that list is not a triviality, and nobody gets it by adding a few tags.

The reason is that every one of those five things has to agree with every other one, and with the live checkout, forever. The price in the JSON-LD has to match the price in the API, which has to match the price Stripe will actually charge. The offers listed in llms.txt have to be the offers that exist. A draft offer must not leak into the sitemap. An internal link in a post must resolve after the post is renamed.

I got each of those wrong at least once. So the site now runs a dozen checks on every deploy, and the deploy fails if any one of them does. A few of them, and why they exist:

  • A check that every offer price in prose matches the catalog, because a blog post once quoted a price that had changed.
  • A check that the JSON-LD on every offer page matches the single source of truth for the catalog, because a hand-copied block drifted.
  • A check that the API’s OpenAPI document matches what the API actually serves.
  • A check that the live site is reachable from the edge after deploy, because for a while every deploy rebuilt the site in place and served 404s to ClaudeBot for the length of the build. Nine of those were on the homepage. That is a deindexing signal aimed at the exact visitors the business depends on.
  • A check that llms.txt lists every published post and withholds every draft.

The fix for the 404 problem was to build each release off to the side and flip a symlink. Ordinary engineering, but it had to be found, built, tested by deliberately breaking it, and kept. Multiply that by a dozen and you have the months.

And this morning, while publishing a different post, a deploy failed on one of those gates for an unrelated reason. The site never blinked, because the gate did its job. That is what the checks are for.

I did not do this alone

I could not have built this without AI coding agents. I use Claude Code, Codex, and Grok Build, and I have written before about working inside them all day.

What they did that I would not have: read the schema.org and Google structured-data documentation in full and kept it straight. Wrote the gates, then wrote the tests that prove each gate fails when it should. Noticed when a check had quietly become a no-op. Found the 404s in the nginx logs and counted them. I supplied the intent, the judgment, and the decisions about what the business sells. They supplied the reading and the patience.

I have thirty-plus years in software and I still would not have read all of that documentation. The agents did, and they did not get bored.

Run the test on your own site

You can do what I did. Open Gemini, or Claude, or any model that can actually fetch web pages, and ask: “Is [your site] well prepared for AI agents and agentic commerce?” Read what comes back. Whatever it lists as missing is your to-do list, in rough priority order, for free.

If you want a scored version with the structured data checked line by line, I sell one.

The JSON-LD audit costs $39.99, runs in minutes, and now includes an Agent Readiness Score out of 100 with the five things above checked explicitly. I ran it on my own site this afternoon and it came back 100. This morning one of its five checks read “missing,” because the check did not yet know that my API contract lives on a different host. I fixed the check. That is roughly how all of this goes.

Talk to me

I built this site to be found by machines, but I am a person, and I would rather talk than be emailed. If you have a question about your own site, or you ran the test and do not understand the answer, call me at +1 (425) 979-2282. I pick up. If I am with someone, leave a message and I will call you back the same day. If you prefer, book a time or write to john@common-sense.com. There is no form between you and me.