A client can have the best business in town, glowing reviews, and a website that looks immaculate on every screen — and still be completely invisible to AI for one unglamorous reason: when the assistant goes to read the page, the content isn't there yet. This is the JavaScript problem, and if you run an agency, it's the gap most likely to be quietly tanking a client who otherwise does everything right.
To explain it to a client — and to sell the fix — you first have to understand why an AI assistant behaves the way it does when it visits a page. So start there, with the machine's point of view, because once that clicks, everything about this factor stops feeling technical and starts feeling obvious.
When an AI system looks at a website, it usually grabs the raw page the way it arrives from the server — the initial HTML — and reads that. A human browser does something extra: it runs all the JavaScript, which then paints in the menus, the services, the hours, the body copy. The assistant's reader generally doesn't run that JavaScript at all — so whatever the script would have painted in never reaches it, and it sees the page in its undressed state. To the machine, a content-rich site can look like a nearly empty shell.
Here's the part that matters for selling it: the AI isn't being lazy. It's being economical on purpose. An assistant fielding enormous volumes of requests — ChatGPT alone handles on the order of a billion searches a week — can't afford to run a full browser and execute every site's scripts the way a patient human's browser does. It reads the raw text reply the server sends, and it moves on. From the AI's side of the table, that's a rational risk decision: spend the least effort needed to get a reliable answer. A business whose content only appears after JavaScript runs simply isn't in the text the AI reads, while the competitor whose facts sit right there in the HTML can be read at a glance — so the assistant leans toward the one it doesn't have to work for.
This is the factor no other factor can rescue. A client can have flawless reviews, a perfect business profile, and pristine listings across the web — and none of it helps if the assistant reaches the homepage and finds nothing it can read. Every other signal in the AI Ranking Factors series assumes one thing: that the machine can actually see the content. Crawlability is the floor the whole building stands on. When it fails, the business isn't ranked low — it's absent from the conversation entirely, which is far worse and far harder to notice, because to a human the site looks perfect.
That invisibility is also why this is such a satisfying problem to bring to a client. It is rarely a reputation issue or a quality issue. It's a plumbing issue. The business is real and good; the machine just can't find the evidence. That reframe — "you're not losing on merit, you're losing on rendering" — lands well, because it tells the owner the problem is fixable and not their fault.
The diagnosis doesn't require deep tooling. View the raw page source — the HTML the server sends, not the rendered page — and look for the things that matter: the core services, the city, the phone number. If that text is sitting right there in the source, the AI can read it. If the source is mostly empty containers and script tags and the real content is nowhere to be found, you've located the leak. Modern builders and frameworks lean on JavaScript precisely because it makes sites feel slick and interactive, which means this problem is widespread and almost never intentional. And the same script-heavy build that hides content from the AI's reader often weighs the page down for human visitors too — a sluggish, clunky load sends people bouncing to a competitor before they ever become the satisfied customer whose review the AI later reads, so the cost lands twice: once directly, where the machine can't see the page, and once indirectly, through the people whose opinions it does.
When you take it to the client, don't lead with rendering or hydration. Lead with the stakes: "Right now, when an AI assistant checks you out, it sees a blank page where your business should be. Your competitors don't have that problem." That's the whole pitch. The value an agency adds here isn't knowing the jargon — it's being the one who noticed, and who can name exactly what needs to change.
The remedy is conceptually simple: make sure the core content exists in the HTML the server sends, before any script runs — through server-side rendering, static generation, or a builder setting that outputs crawlable markup. But notice the division of labor. The agency diagnoses the problem and decides it's worth fixing; a developer is the one who actually applies the change in the client's stack. And the real friction almost never lives in the writing of the fix — it lives in handing the technical resource the exact change to make. Producing that precise spec, rather than typing it into the codebase, is usually the slow part; the change itself can be generated as a ready-to-apply spec rather than authored from scratch, which is the kind of tedious, easy-to-fumble handoff that goes faster when it's coordinated and tracked in one place instead of relayed in scattered emails.
None of this is exotic work. It's a small, well-understood correction that happens to sit upstream of everything else. Get it right and the rest of the client's hard-won signals — the reviews, the profile, the citations — finally become visible to the machine that decides who gets recommended. As more buying journeys start with an assistant rather than a search box, "can the AI even read this page" stops being a technical footnote and becomes the first question worth asking about any client you take on.
A scan reads a site the way an AI system would and reports whether the real content shows up — or whether it's hiding behind JavaScript without anyone realizing it.