English · Українська · Polski
GetLoopLoop skills
Vectorscope skill 2.116. Versions count in thousandths (2.101, 2.102, …), so the first number moves only on a breaking change.
Agent Skills from GetLoopLoop, for claude.ai and the Claude desktop app, Claude Code, Codex, opencode, Hermes Agent and other agents that load SKILL.md skills.
| Skill | What it does |
|---|---|
vectorscope | Shows how a retrieval system reads public pages: the product's exact fetch, extraction, chunking and 26-passage cap, robots.txt verdicts for AI crawlers, automatic structure checks, how generated the text sounds, and the agent's grouping, query test and rewrite plan. Compares 2 to 5 pages. The report is in English, Ukrainian and Polish. |
sitemap-watch | Remembers which pages a site's sitemaps list and shows what changed since the last look: new pages, removed pages, changed lastmod, and the new pages grouped by section. Built for "what's new at my competitors": the script counts and compares, the agent says what the new sections suggest. Node built-ins only, no install. |
In plain words
Before an AI assistant can quote your page, a machine has to read it, and it does not read it the way you do. It fetches the page once, throws away the menus, buttons and footers, and cuts the rest into passages of about 2,000 characters. It keeps at most 26. Each passage is later found and quoted on its own, without the page around it.
This skill runs those same steps on any public page and tells you what to fix: whether AI crawlers are even allowed in, which passages lost their question or their subject, what fell past the 26-passage limit, which typical questions the page answers and which it does not, how templated the text reads and which passages say nothing a competitor's page could not, and how to rewrite the weakest passages so each one stands on its own.
It does not rank your page, decide who wrote it, or predict what any assistant will say about you.
Features
- The machine's reading: the exact fetch, extraction, chunking and 26-passage cap of the live tool; how many words survive, how many passages they become, what falls past the cap.
- Measured, derived, judgement: every section and number carries a tag saying whether the parser measured it, a fixed formula derived it, or the agent judged it; the export splits into
measuredandjudgementthe same way. - How generated the text sounds (2.111, the last open section, above Where the text goes): the Pattern score of the GetLoopLoop PatternScope over the page's text (stock phrases, repeated sentence shapes, sentences that open the same way, claims with no number or name; the web tool's rules, with two adjustments for a whole page rather than a pasted text, for English, Ukrainian and Spanish), the words language models overuse counted beside it, and the agent's swap test: which passages would fit a competitor's page with only the name changed. Passage by passage, with the findings behind every point; where the script and the agent disagree, both are shown. Not an authorship detector, and the block says so.
- Where the text goes (at the end of the report, folded under a line that gives the characters past the cap): a character waterfall from the raw HTML to the passages (removed by the cleaner, kept, in passages without double-counting the overlap, past the cap), a table of what the cleaner removed and why (the element, its CSS path, its characters, how its text begins), and a map of how much of each section reached a passage.
- Every number explained: a "?" beside each number opens its formula, unit, threshold and known limits, in English, Ukrainian or Polish; the Markdown ends with the same list and the export carries it as a
metricsdictionary. - An honest past-the-cap count: characters past the cap are counted from the unique text in passages, so a page whose cap cut a tail no longer reads 0; the 2.101 number stays in the export as
charsUnread. - AI crawlers first: robots.txt checked for GPTBot, OAI-SearchBot, ChatGPT-User, ClaudeBot, Claude-SearchBot, Claude-User, PerplexityBot, Perplexity-User, Google-Extended, Googlebot, Bingbot and CCBot, with RFC 9309 matching. If the crawlers that answer people are blocked, the report says so before anything else.
- Automatic checks, each with a code, the passages it rests on and the evidence: FAQ answers that lost their questions, one heading carrying too much of the page, passages cut mid-sentence, navigation inside the content, thin sections, truncated teasers, the same claim in every section, canonical, JSON-LD and meta description.
- Response headers and accessibility: the
X-Robots-TagandCache-Controlheaders are read and checked (a header noindex is as serious as meta robots), and the page's images and heading order are read for missing alt text, filename-only alt, level jumps and multiple h1. - The page's vocabulary, phrases first: the two-to-four-word phrases the page owns, ranked by how many passages use them, then its narrative words. What the page says, not search demand.
- Grouping by the agent's reading: the passages grouped by subject and named, with the page's own heading or keywords kept as the label source.
- Query test: 5 to 10 typical questions (yours or the agent's), the best passage for each, whether it answers completely, and the exact words a retriever could quote.
- Rewrite plan: prioritised fixes tied to the checks, with before → after rewrites for the weakest passages.
- Compare 2 to 5 pages on one shared topic dictionary: a topic × page table, topic gaps, fact gaps, and who wins each query.
- Before and after: diff a page against an earlier reading.
- Optional JavaScript render with a local Chrome or Chromium, to see how much of the page only exists after scripts run.
- One self-contained HTML report with no network requests, readable on a phone, its interface in English, Ukrainian or Polish; plus Markdown and JSON.
Why the groups are "the agent's reading": the live tool groups passages by comparing their embeddings. This skill makes no model or embedding calls, so the agent that runs it reads the passages and groups them by subject instead. The fetching, the cutting, the cap and the checks are deterministic; the grouping, the query verdicts and the plan are a judgement, and the scripts validate each of them (every quote must be verbatim from its passage). For the embedding-based reading with the map, use the free tool at https://www.getlooploop.com/vectorscope.
What you get
How generated the text sounds: the Pattern score, the marker words, the agent's swap test, the two strips side by side and every passage with its evidence:
How generated the text sounds
The same block with the interface in Polish:
How generated the text sounds, in Polish
The tags beside every section and number, and the info panel that explains them:
Info panel and the measured, derived and judgement tags
Where the text goes, from the raw HTML to the passages:
Character waterfall
What the cleaner removed, largest first, and how much of each section reached a passage:
Removals table
Section map
The "?" beside a number: its formula, unit, threshold and limits:
A metric's explanation, open
The top of the report: the pipeline, the counters and the reading strip:
Report header: pipeline, counters, reading strip
The same report with the dark theme switched on:
Report header, dark theme
The same report with the interface in Ukrainian (page content is never translated):
Report in Ukrainian
The checks: the AI-crawler table first, then the technical markup and the findings, each with its passages and what to do:
AI crawler table and checks
The rewrite plan, with before → after:
Rewrite plan with before and after
The query test:
Query test
The page's vocabulary: the phrases it owns first, its narrative words second:
Phrases this page owns, then narrative words
Comparing two pages: topics × pages, topic gaps, and who wins each query:
Compare mode
The footer, and the report on a phone:
Footer
Three real runs are in examples/, each with the files the agent wrote in examples/judgement/. The two single-page reports were rendered again with 2.111 on 18 October; the comparison is the 2.110 report, because web.dev now declares a Russian version and a comparison needs two readable pages:
- the Vectorscope page itself, which needs 17 passages and loses nothing to the cap; its Pattern score is 1 of 100 with no marker words, and the swap test finds 4 of its 17 passages generic (HTML, Markdown, JSON);
- the Wikipedia article on large language models, which fills every slot and leaves 55,001 characters past the cap, six sections reaching no passage at all; its Pattern score is 10 of 100, almost all of it citation formats in the references, and the swap test finds 3 of 26 passages generic (HTML, Markdown, JSON);
- MDN's HTTP caching guide against web.dev's HTTP cache article; MDN fills every slot and, since 2.103, loses nothing past the cap: its h3 "Validation" no longer cuts "Common caching patterns", and the slot that cut used now holds the page's last section (HTML, Markdown, JSON).
Install
The skill needs Node 20.18 or later (what cheerio declares) and no npm install: dist/read.mjs and dist/lens.mjs are the scripts bundled with their one dependency, cheerio, so plain node runs them, including in sandboxes that block package installs. The readable source is in scripts/; dist/ is generated from it (see Working on the skill).
As a plugin (Claude Code, Google Antigravity), recommended
Claude Code:
/plugin marketplace add Olexan-art/getlooploop-skills
/plugin install vectorscope@getlooploop-skills
Then turn on auto-update: in /plugin, open Marketplaces, select getlooploop-skills and choose Enable auto-update. Until you do, Claude Code keeps the version you installed; /plugin marketplace update getlooploop-skills fetches a newer one by hand.
Google Antigravity:
agy plugin install https://github.com/Olexan-art/getlooploop-skills
To update, run the same command again.
The repository carries plugin.json and .agents/plugins/marketplace.json for Antigravity, gemini-extension.json for Gemini CLI and .claude-plugin/ for Claude Code, with the skill in skills/.
Update check and usage count
Once a day, the report script (lens.mjs) asks getlooploop.com for the newest version of the skill. The request carries the skill's name, its version, the operating system (win, mac, linux or other), a random install id kept in ~/.getlooploop-skills/install-id, and how many times the skill ran since the last check. That is all: nothing about the pages you audit, no URL, no domain, no user or machine name. The server derives a country from the connection and does not store the IP address. If getlooploop.com does not answer, the skill reads the version from this repository's plugin.json on GitHub instead. A newer version is one line in the terminal and a notice in the report; the agent offers the update command and runs it only if you agree. Switch it off with GETLOOPLOOP_NO_UPDATE_CHECK=1 or --no-update-check (it is also off when CI is set): then nothing is sent and no id is created. Delete the ~/.getlooploop-skills folder to reset the id.
One command (Claude Code, Codex, opencode and other agents)
npx skills add Olexan-art/getlooploop-skills --skill vectorscope
The skills CLI asks which agents to install it for (add -g for every project, -a claude-code to pick one). Then ask your agent to "run vectorscope on ". Later, npx skills update vectorscope brings it up to date.
claude.ai and the Claude desktop app
- Download
vectorscope.zipfrom this repository's Releases. Do not unpack it: the upload takes the zip, with thevectorscopefolder at its top level. - Turn on code execution: Settings > Capabilities > Code execution and file creation. Skills need it. On Team and Enterprise plans an owner controls it in Organization settings > Capabilities.
- Upload the skill: Customize > Skills, the + button, Create skill, Upload a skill, then choose
vectorscope.zip. Turn the skill on in the list. In the desktop app it is the same Customize > Skills page. - Let the sandbox reach the site you want read. A run fetches the page and its
robots.txt, and code execution only reaches what its network setting allows. On Free, Pro and Max plans that setting is Allow network egress in Settings > Capabilities. On Team and Enterprise plans an owner chooses in Organization settings > Capabilities: off, package managers only (the default), package managers and specific domains, or all domains. With specific domains, add the site's domain. If your plan's setting cannot allow the site, the run stops withREFUSED unreachableand says so; use Claude Code or another agent on your own machine for that page. - In a chat, ask: "run vectorscope on https://example.com/page". Claude runs the scripts in the sandbox and hands you
report.htmlas a file to download and open in your browser, with a short summary in the chat.
Pasting this repository's link into a chat is not installing it. Claude rightly will not download and run code from a link someone pasted, so it will at best imitate the steps by hand, and those numbers are not the tool's. Upload the zip as above.
Sources: Use skills in Claude · Create custom skills (the zip's structure, the name and description rules) · Create and edit files with Claude (code execution and network egress) · Agent Skills overview (network access by surface). Checked on 2026-10-16.
No internet in the agent's shell
Cloud sandboxes often run the shell offline or keep the skills folder read-only. The skill does not need a skills folder: unpack vectorscope.zip anywhere the agent can write and point it at that folder (or attach the zip to the chat). With no network, save the page in your browser as "Web page, HTML only" and, if you can, its robots.txt, and give both files to the agent: the skill reads the saved copy and marks every check that needs the network as not checked.
Use it with your agent
The skill is one folder, skills/vectorscope, with a SKILL.md and Node scripts. Agents that support Agent Skills load it from their skills directory; any other agent can follow SKILL.md as instructions. Either way the agent runs the same scripts from the skill folder, and the agent's own model does the reading. No install step: the agent runs node dist/read.mjs and node dist/lens.mjs as they are.
git clone https://github.com/Olexan-art/getlooploop-skills.git
Claude Code loads personal skills from ~/.claude/skills/ and project skills from .claude/skills/.
mkdir -p ~/.claude/skills && cp -r getlooploop-skills/skills/vectorscope ~/.claude/skills/vectorscope # personal
mkdir -p .claude/skills && cp -r getlooploop-skills/skills/vectorscope .claude/skills/vectorscope # or: this project only
New-Item -ItemType Directory -Force "$HOME\.claude\skills" | Out-Null
Copy-Item -Recurse getlooploop-skills\skills\vectorscope "$HOME\.claude\skills\vectorscope"
OpenAI Codex (CLI, IDE extension, app) scans $HOME/.agents/skills (user) and .agents/skills in every directory from where you launch it up to the repository root (repo).
mkdir -p ~/.agents/skills && cp -r getlooploop-skills/skills/vectorscope ~/.agents/skills/vectorscope
New-Item -ItemType Directory -Force "$HOME\.agents\skills" | Out-Null
Copy-Item -Recurse getlooploop-skills\skills\vectorscope "$HOME\.agents\skills\vectorscope"
opencode loads global skills from ~/.config/opencode/skills/, ~/.claude/skills/ or ~/.agents/skills/, and project skills from .opencode/skills/, .claude/skills/ or .agents/skills/ (walking up to the git worktree). A copy made for Claude Code or Codex above is picked up too; otherwise:
mkdir -p ~/.config/opencode/skills && cp -r getlooploop-skills/skills/vectorscope ~/.config/opencode/skills/vectorscope
Hermes Agent (Nous Research) keeps skills in ~/.hermes/skills/. It also reads <project>/.hermes/skills/ and <project>/.agents/skills/ once you trust the repository with hermes skills trust, and any folder listed under skills.external_dirs in ~/.hermes/config.yaml (for example ~/.agents/skills).
mkdir -p ~/.hermes/skills && cp -r getlooploop-skills/skills/vectorscope ~/.hermes/skills/vectorscope
GLM (Zhipu / Z.ai) is a model family, not an agent. Z.ai's GLM Coding Plan is used inside coding agents; its documentation names Claude Code, Codex and OpenCode among them. Install the skill for the agent you run GLM in, as above: the skill then follows that agent's instructions, and GLM does the reading.
Any other agent: point its instructions file (for example AGENTS.md) at the skill, so it reads the steps before it starts:
For questions about how AI assistants read a web page, follow skills/vectorscope/SKILL.md and run its scripts from that folder.
Sources: Claude Code skills · Codex skills (where developers.openai.com/codex/skills now redirects) · opencode skills · Hermes Agent skills · Z.ai GLM Coding Plan. Checked on 2026-10-16; skill folders move between releases, so check your agent's current docs if a path does not work.
Vectorscope, in short
node dist/read.mjs https://example.com/page --out reading.json # fetch → extract → chunk → cap, robots.txt, checks
# the agent reads the passages and writes groups.json
node dist/lens.mjs reading.json groups.json --html report.html # labels, phrases, all checks
# the agent writes queries.json, style.json and plan.json
node dist/lens.mjs reading.json groups.json --queries queries.json --style style.json --plan plan.json --html report.html --md report.md --json export.json
node dist/read.mjs <url1> <url2> --out-dir readings # compare; then topics.json, groups-<n>.json, facts.json, queries.json
node dist/lens.mjs --compare readings/manifest.json --html readings/compare.html
The scripts make no model or embedding calls and send nothing anywhere except the GETs for the page and its robots.txt (and, with --render, the local browser loading the page). Fields that would need vectors (cohesion, self-similarity, the projection) are reported as null instead of being estimated. The HTML report escapes every piece of page text and carries a content security policy that blocks all network requests from it, because the passages are third-party content.
Sitemap watch
Sitemap watch, the skill that remembers which pages a site's sitemaps list and shows what is new since the last look, has its own repository: Olexan-art/sitemap-watch, with its install steps and pictures. Install it with npx skills add Olexan-art/sitemap-watch --skill sitemap-watch.
AI Search Audit Lite
AI Search Audit Lite, the SEO and AI search audit of one page that runs the Vectorscope reading alongside the Google and Bing checklist, robots.txt, structured data and language versions, has moved to its own repository: Olexan-art/ai-search-audit, with its install steps, examples, screenshots and the claude.ai zip in its Releases. Install it with npx skills add Olexan-art/ai-search-audit --skill ai-search-audit.
Asking your agent
A short request with a clear stop condition and a reply format keeps the agent on the procedure. Copy it and put in your page:
## Task
Run the skill `vectorscope` on 1 page. Write its report.
## Inputs
- Page: https://example.com/page
- Working folder: ./vectorscope
- Compare with (optional, at most 4): https://example.com/other
## Rules
1. Read SKILL.md first. Follow it exactly.
2. Write every file into the working folder.
## Stop condition
Stop when report.html exists. Show it.
## Reply format
- The report link or path.
- The 3 main findings, with the passages they cite.
Working on the skill
scripts/ is the source; dist/ is built from it with esbuild (a development dependency only) and committed, so the skill runs without an install.
cd skills/vectorscope
npm install # cheerio, and esbuild for the build
npm run build # scripts/ → dist/read.mjs, dist/lens.mjs (not minified, readable)
npm test # includes a check that dist/ equals a fresh build, so dist never drifts from scripts/
npm run zip # dist-release/vectorscope.zip, the file to attach to a release for claude.ai
Change scripts/, run npm run build, and commit both.
Licence
Free to use, change and share under the MIT licence, see LICENSE. If you publish something built with it, a link to getlooploop.com is appreciated.