AI Search Audit Full: an SEO audit that quotes its rules

Most audits end in an argument. The tool says the page has a problem, somebody asks who says so, and the answer is a score or a vendor's opinion. AI Search Audit Full is built the other way round. Every problem it reports carries the rule it rests on, quoted word for word from the source that published it, with a link and the date the quote was checked. Where nobody publishes a rule, it says the threshold is its own.

We introduced the skill beside Vectorscope and Lite in AI reads your page in pieces. Three free skills show which ones. This piece goes deeper into Full alone, at version 2.111: what it checks, what it found on our own site, the four things it gained since that article, and where its limits are.

What it checks

Before Google, Bing or an AI assistant can show or quote a page, three things have to hold. A crawler has to be allowed in, by robots.txt and by the page's own robots tags. The page has to say what it is: title, description, canonical, structured data, language versions. And the text has to survive the machine's reading: what a cleaner keeps, how it is cut into passages, and what falls past the point where a retriever stops.

Full checks all three against published rules, then adds three readings only an AI can make: the questions people would ask about the page, how the agent's own model describes the brand, and what it believes about the brand's reviews. Those readings are marked as the model's estimate, with the model named, everywhere they appear.

Its example in the repository is a three-page site audit of getlooploop.com: the Vectorscope page in English, Ukrainian and Spanish, read live on 17 October 2026.

The headline first, because it is the reason to run an audit at all: nothing blocks these pages. All twelve crawlers the skill checks, from Googlebot and Bingbot to OAI-SearchBot, Claude-SearchBot and PerplexityBot, are allowed. No finding is blocking or high. On each page 25 of the 35 checklist items pass outright.

The one item that fails is the useful kind. The checklist's broken-links check found two links in the "Keep reading" block that lead to 404 pages: /notes/what-is-semantic-chunking and /notes/optimise-content-for-ai-search, on all three language versions. We had not noticed. Both pages had been planned and never written; on 23 October, while writing this, we pointed the block at articles that exist. An audit that finds something real on its authors' own pages, and gets it fixed the same day, is doing its job.

Every problem comes with its rule

Each finding in a Full report opens into three layers, written for three readers.

What goes wrong is for a manager or a junior: plain words, no advice. For the broken links: "Links on the page lead to an error page. People who follow them hit a dead end, and search engines drop such addresses from their index."

What the rule says is for whoever asks "says who?": a short quote from the official source, its link, and the date it was checked. For the same finding it quotes Google's page on HTTP status codes:

The fix direction is for the developer, terse and technical, folded inside "Details for specialists" so it never crowds the plain layer: "Update or remove hrefs that return 4xx or 5xx; 301 moved targets to their new URL."

The same pattern explains findings that are not errors at all. The pages carry FAQPage markup, and the audit reports it as low: the markup "does no harm, but it no longer earns the expanded result it was once added for", because, in the words it quotes from Google's documentation updates, "The FAQ rich result feature is no longer shown in Google Search results". The fix direction is honest about the choice: nothing required for Google; keep it if another consumer reads it, or remove it to lighten the page.

Counted from the skill's own rule table (explain.mjs and rules.mjs), 122 problem codes rest on 83 quotes and 39 rules of its own. Google Search Central supplies 53 of the quotes, which is what you would expect of an audit for search. The rest come from the standards bodies (W3C, WHATWG, the IETF's RFC 9309 for robots.txt), MDN, and the AI companies' own crawler pages: the OpenAI quote is the one that decides whether a site can appear in ChatGPT's search answers at all.

The 39 own rules matter as much as the 83 quotes. A passage that starts mid-sentence, a section thinner than the skill's threshold, an llms.txt that lists one language on a three-language site: nobody publishes a rule for these, so the report says "This skill's rule" and the README names the threshold. Nothing is attributed to Google that Google did not write. And the quotes are not a snapshot taken once: npm run verify-rules fetches every source again and compares each quote word for word.

The answer map: which questions the page can answer

New since our first article, the answer map puts the questions people would ask about a page in one table: whether the page answers each one, a quality out of 100, and what is missing. The questions and verdicts are the agent's judgement; the quality is a fixed sum the script computes, so the same files always give the same number. A complete answer earns 50 and a partial one 25; an answer quotable on its own earns 25; an answer that opens its passage, measured by the script, earns the last 25. A partial answer can never reach 100.

Read from the bottom, the page is in good shape: half of the twelve questions get a complete answer that can be quoted on its own, and one, "can this tell me if it's indexed?", gets a perfect answer that opens its passage: "This does not establish that any assistant has indexed the page." Read from the top, it is a content brief. Nothing on the page says whether a PDF link works, or what happens to a page behind a login, and the launch-day question about the FAQ below the cut is answered only in part. The three "add first" labels are the next three paragraphs to write, ordered for you.

The quality is deliberately strict. Five complete answers stop at 75 because their answer sits in the middle of a passage rather than at its start. Assistants quote passages, and the first sentence of a passage is the one most likely to be quoted, so the score rewards the answer that comes first.

Heat: where on the page the problems sit

A list of nineteen findings does not say where to start. The page map does: it draws the page as a schema, from <head> and robots.txt down to the footer, and pins each finding to the place it was found. Since 2.111 each place is also shaded by heat, its findings weighted by severity (blocking 8, high 4, medium 2, low 1) against the hottest place. The site report's grid of pages and problems is shaded the same way.

The picture is reassuring and specific at once. Nine or ten of the fourteen places on each page carry no finding at all. The heat sits in three: the "Keep reading" block at the bottom (the broken links, a passage that starts mid-sentence, a repeated sentence shape, a partial answer), the <head> (a required field missing from the structured data, two retired rich results, the page's weight), and the "How to read your result" section, which is long enough to be cut mid-sentence. Three fixes, in three known places, on three pages built from one template: one ticket, not nineteen.

The hero on the Ukrainian page is the one place where the language versions differ: it reads 5 there and 3 elsewhere, because the audit's keyword check found the Ukrainian page's main phrase confined to few sections. That is the kind of difference a site report exists to show.

How generated the text sounds

Since 2.109 the bottom of every page report carries a block called "How generated the text sounds". It puts three readings side by side: the Pattern score from the writing patterns (stock phrases and repeated sentence shapes, counted with their positions), the words language models are known to overuse, and the agent's swap test, a verdict per passage on whether it could be pasted into a competitor's page unchanged. Where the agent and the script disagree, both are shown, never averaged. It is not an authorship detector, and the block says so.

Low scores across all three languages, and not one overused marker word. The passages the swap test calls generic are the caveats ("This does not establish that any assistant has indexed the page") and the "who is it for" paragraph: sentences that any tool's page could carry, which is a fair note for an editor. The value is in the positions: each signal points to a passage and a word, so a reviewer can check the claim in seconds rather than trust it.

A history that outlives the chat

Every run is saved as a snapshot, and every report shows what changed since the last one: title, description, canonical, h1, word count, schema types, robots.txt and each bot, hreflang, passages new, lost and changed, and findings fixed, new and unchanged. Since 2.110 the history lives in the user's own folder, ~/.ai-search-audit/history, which a new chat, a new working folder or a new version of the skill does not reset. And because a chat sandbox such as claude.ai may forget its disk, every report also carries the whole history inside it: --history-from report.html takes it back on the next run.

The committed example shows how carefully the drift is read. The first run of /vectorscope, on 16 October, read a saved copy and found 18 problems; the live run on 17 October found 19. Nothing got worse. A saved file has no HTTP response headers, so the first run reported the security-headers check as not measured; the live run measured it and found three headers missing. The drift records the word count going from 2,463 to 2,469 and exactly one of the 17 passages changing. /es/vectorscope, read live twice less than a minute apart, shows 18 and 18 and no change, which is what a stable audit should say.

What changed since 2.106

Five releases in two days, from the repository's commit history:

Install and run

The skill needs Node 20.18 or later and no npm install: its scripts are bundled. For Claude Code, clone the repository and copy the skill folder into your skills folder (Codex, opencode and Hermes Agent take the same folder in their own paths, listed in the README):

Then ask the agent in plain words: "an AI search audit of https://example.com/page", or "audit these pages of my site". For claude.ai and the Claude desktop app, download ai-search-audit-full.zip from the repository's releases, turn on code execution, and upload it under Customize > Skills without unpacking it. Under the hood the agent runs two scripts, with its own judgement files in between:

A site audit is polite by construction: pages are read one at a time, at least a second apart, longer when robots.txt sets a crawl delay, and only where robots.txt lets it in. In the example, 81 requests went out for three pages and 39 more were answered from memory, because robots.txt, the sitemap and shared links are fetched once.

What it doesn't do

• No score for the page. Findings, each with its evidence and its rule; never a number out of 100 for the page as a whole. The answer map's quality is per question.
• No field data, no index status. Core Web Vitals and "is this in Google's index" are always reported as not measured: they need real-user data and Search Console.
• No prediction of what assistants answer. The brand and review readings are one model's knowledge, labelled with that model's name. On our pages the model, Claude Opus 5.5, did not know GetLoopLoop, and the audit says exactly that.
• Not a whole-site crawler. At most 50 pages; site-wide checks see only the audited set, and the report says that an orphan page there may still be linked from outside it.
• Public pages only. No login, no cookies, no private addresses, and no JavaScript rendering unless asked. Every cap is named in the report, never applied silently.

The verdict

On three real pages, the audit did what an audit should. It cleared the things that would have been serious, with evidence: every crawler allowed, no blocking or high findings, 25 of 35 checks passed. It found a real defect its own authors had missed, two dead links, and explained it in a sentence a manager can read, a rule a specialist can check, and a fix a developer can apply. It turned twelve questions into a ranked list of three paragraphs to write, and nineteen findings into three hot places on one template. And every one of those claims can be checked: the rules against their sources, the numbers against the files in the repository.

That is the case for running it before you publish, and again after you fix. Install it from GitHub, point it at the page that matters most, and read the first thing it finds. The rest of the setup is on Agent Skills for SEO, GEO and marketing teams, and what the assistants actually say about your brand, measured over weeks rather than once, is what GetLoopLoop is for.