We started inside hosted website builders in 2020 and did not write our own code until 2022. The 232-page index shows what happened next.

AI visibility is not something you add to a website. It is what is left over after hundreds of small technical decisions.

We know because we wrote every one of them down. Our index of AI-assisted code on a single live site now runs to 232 pages, and it reads less like documentation than a map of everything sitting between the source code and what a machine can actually retrieve from a page. It is an implementation record, not 232 pages of production code: each entry logs what was added, where it lives, what type of implementation it is, and which tool produced it.

Key Takeaways

We Did Not Start Here

We did not start by writing front-end systems. From early 2020, our work lived inside hosted website platforms, the kind that are excellent right up until you ask them for something slightly outside the box.

Our level then was practical, not technical. Pages, layouts, content, forms, ecommerce, and the usual collection of widgets and settings every hosted platform comes with.

Then the limits started to matter. A section would not behave on mobile, a third-party embed loaded too slowly, and a page that looked right in the editor exposed very little useful HTML underneath. Some things the platform simply would not let us change.

By 2022, we had started working around the edges with small HTML and CSS fixes. From there came JavaScript, structured data and increasingly custom components. As AI coding tools improved, that evolved into what people now call vibe coding, then AI-assisted development in proper IDEs and more complex systems.

Most of it came through trial, error and an unreasonable number of browser tabs.

AI accelerated all of that. It did not remove the learning curve. It compressed it.

That is why we still understand the frustration of hosted platforms. We know what it is like to hit a wall inside a builder and be told that is just how the platform works, and we know that “the platform does not support it” is not always the same as “it cannot be done.”

Sometimes the answer is a clean custom component, better server-delivered HTML, a replaced embed, or structured data. Sometimes it is a workaround. And sometimes the right answer is to stop fighting the platform and move the job somewhere better suited to it.

Why Did We Start Documenting Every Piece of AI-Assisted Code?

Because we wanted to know what had actually changed. Every custom component, schema block, third-party embed, script, mobile fix and AI tool involved went into one record.

Once we started writing our own code, we needed a way to keep track of it. Hosted builders gave us the page editor, but not the kind of implementation history we needed, so the index became our running record of what changed and why.

The early entries were small: a couple of responsive cards, a button, a checklist, a mobile layout.

That work used to mean finding a developer, explaining the change, waiting, and then discovering the button had moved twelve pixels to the left on an iPhone. With AI, we described what we wanted, generated the HTML and CSS, tested it and shipped it the same afternoon.

None of those changes mattered much on their own. Then there were hundreds of them.

What Does a Modern Website Actually Run Underneath?

Far more than it shows. The index moved past visual components quickly and into code doing real jobs.

It now covers Organization, Person, Service, FAQPage, VideoObject and BreadcrumbList structured data. It covers internal linking components, modal interfaces, client-side search, form integrations, Calendly embeds, video players, review widgets, and JavaScript that changes behavior by device.

At one point, the site’s global setup included Organization schema alongside Google Analytics, Google Tag Manager, Microsoft Clarity, Trustpilot, affiliate tracking, cookie consent, and Bing and X tracking. That is a fairly normal modern website. Written down in one place, it stops looking normal.

Why Does the Browser Give You the Wrong Picture?

Because a browser does work that many AI crawlers skip. It executes JavaScript, loads third-party services, applies CSS and waits for things to appear.

The result is that a chaotic pile of files looks deliberate. Two pages can look identical to a person and be completely different to a machine.

The clearest evidence comes from Vercel and MERJ’s December 2024 server-log study. Across the sites they monitored, none of the major AI crawlers rendered JavaScript, including OpenAI’s GPTBot, OAI-SearchBot and ChatGPT-User, Anthropic’s ClaudeBot, and PerplexityBot. They fetched JavaScript files but did not run them, while traditional search crawlers such as Googlebot can render JavaScript.

Newer independent testing found broadly the same pattern. Glenn Gabe’s August 2025 tests found that ChatGPT, Perplexity and Claude could not retrieve content that depended on client-side JavaScript.

EdgeComet’s January 2026 tests found that ChatGPT-User fetched raw HTML without executing JavaScript, while GPTBot showed only extremely limited execution rather than dependable page rendering. Crawlers can change, but the practical gap has held. Here is the same reviews section built two ways:

<!-- Version A: the content is in the HTML -->
<section class="reviews">
  <h2>What clients say</h2>
  <blockquote>Review text lives here, in the page source.</blockquote>
</section>
<!-- Version B: the content arrives later, from someone else's script -->
<div id="reviews-widget"></div>
<script src="https://widget.example.com/embed.js"></script>

In a browser, both can look the same. To a crawler that does not execute JavaScript, Version B may be little more than an empty container and a script reference.

So “does the page look right?” is the wrong question. The useful ones are: is the information in the initial HTML, is it injected later, is it trapped in an iframe, and are the relationships between the business, the author and the service stated explicitly?

When Is Less Technology the Better Fix?

More often than you would expect. One pattern repeated across the index: a third-party widget solved a visual problem quickly, and months later we rebuilt it as native HTML and CSS.

The reason was control. A server-delivered native component can put the useful content directly in the page source, is easier to edit, debug and make responsive, and removes one external dependency.

That does not make every embed a mistake. Vercel’s own recommendation is that client-side rendering is fine for non-essential features like chat widgets and social feeds.

The difference is choosing a dependency on purpose. The alternative is discovering nine months later that half your page disappears whenever someone else’s script has a bad afternoon.

What Role Does Structured Data Play Once You Write It All Down?

It stops looking like an SEO add-on and starts looking like a layer that describes the site. Who is the organization, what does it provide, who wrote this, what is this page about, which video belongs here, which FAQ belongs to which service.

Our Organization markup declares the site’s identity, areas of expertise, founder and related profiles. That does not guarantee an AI citation, and we have not seen any major AI lab document that it does.

What it can do is reduce ambiguity. The working principle is simple: make important facts and relationships explicit wherever reasonably possible.

Why Does AI-Assisted Code Still Need a Reviewer?

Because AI writes code with complete confidence, whether or not the confidence is earned. One comment in the index described a block of HTML and CSS as “100% secure and ‘hack-proof’.”

It was HTML and CSS. We kept the comment in the index on purpose.

Often the code works. The self-assessment is the part that needs checking.

What Happens When Writing Code Becomes Cheap?

The questions change. Early entries in the index are plain HTML and CSS; in the most recent entries, one component is a multi-stage animated walkthrough of a document being scanned, uploaded, reviewed and followed up by email.

The difference between our 2022 work and the later entries in the index is not just more sophisticated code. The judgment behind it changed too. We got better at knowing when to build and when not to, when to replace a third-party tool and when to leave it alone, and when a change mattered for what machines can retrieve rather than just for how the page looked.

Whether AI could write the code stopped being the question. The questions became: should this exist, where should it live, what happens when its dependency fails, does it work on mobile, can a crawler reach the important information, and how do we know it did what we intended?

Cheap code also accumulates. More widgets, more scripts, more schema, more dependencies, and more things someone eventually has to understand. That is how an index reaches 232 pages.

Why Did the Index Turn Out to Be a Map?

Because it shows where information actually lives. What depends on what, which systems are external, which elements exist mainly for machines, which tool created something, and what later replaced it.

That record gets more valuable as AI makes sites easier to change. The faster you can build, the easier it is to forget what you built.

How Can You Check Your Own Site in Two Minutes?

Pick the page that matters most to your business and copy one sentence from it, ideally from a review, a service description or an FAQ answer. Open View Page Source (Ctrl+U on Windows, Cmd+Option+U on Mac), not Inspect, and search for that sentence with Ctrl+F or Cmd+F.

If the sentence is there in the returned HTML, a non-rendering crawler has a chance to retrieve it. If it is missing, that content is not present in the page’s initial HTML. It may be loaded later by JavaScript, live inside an iframe or depend on another external source, so a non-rendering crawler may not receive the same content you see in the browser.

Repeat the test for your business name, your main service and your contact details. The pages that fail are where to start.

Frequently Asked Questions

Q: Do AI crawlers like GPTBot and ClaudeBot run JavaScript?
A: Not in the December 2024 Vercel and MERJ study, which found that OpenAI’s crawlers, ClaudeBot and PerplexityBot fetched JavaScript files without executing them. Independent tests in 2025 and 2026 found broadly the same pattern, while traditional search crawlers such as Googlebot can render JavaScript.

Q: Can third-party widgets hurt my site’s AI visibility?
A: They can if your important content only loads through them. If a review, service description or FAQ is injected by an external script, crawlers that do not execute JavaScript may never see it.

Q: Does adding schema markup guarantee ChatGPT will cite my website?
A: No. Structured data makes your business, services and authorship explicit, but no AI lab has published documentation promising citations in return.

Q: How can I check whether important content is present before JavaScript runs?
A: Start with View Page Source rather than Inspect. Inspect shows the DOM after scripts may have modified it; View Page Source shows the HTML returned to your browser before those changes. For a true crawler test, you also need to inspect server responses or logs for the crawler itself.

Q: Is it safe to use AI to write code for my website?
A: It is useful, but the output needs review. AI tools produce working code quickly and describe it with more confidence than the code always deserves.

Q: Does this apply to hosted website builders and CMS platforms?
A: Yes. The platform may handle the underlying templates, but custom code, third-party embeds, dynamically loaded content and structured data still need to be checked. The same source-vs-rendered-page distinction applies.

AI removed much of the friction from writing code. It did not remove the need to understand what the code changed, what it depends on, or what a machine can actually retrieve.

Two hundred and thirty-two pages later, that turned out to be the actual job.

AI Visibility Studio helps websites become easier for AI systems to find, read, and cite. aivisibilitystudio.com