Skip to main content
skill CX Codex

site-check — Claude Code skill for 3D page testing

The site-check Claude Code skill checks 3D and animated web pages in Chromium and WebKit. Run it after page changes to catch browser errors, mobile layout issues, and slow frames before publishing.

MIT ★ 448 updated 2026-11-09

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add Moh4696/open-3d-skills
/plugin install open-3d-skills@open-3d-skills
Open on GitHub

What site-check does

The skill captures pages across view states, viewport sizes, and scroll positions. It checks page errors, failed requests, blank WebGL canvases, horizontal overflow, and reduced-motion behavior. It also measures frame time, draw calls, and triangles, then saves report.json and a labelled sheet.jpg with problem shots marked in red.

The scripts/check.py script uses Playwright. To collect three.js render counts, the page must expose its renderer as window.__app.renderer. Requirements include Python 3.9+, the playwright and pillow packages, installed Chromium and WebKit browsers, and an HTTP server. The included scripts/serve.py handles Range requests; python3 -m http.server does not support video seeking. Manual checks are still needed for animation seams, interactions, and long-running sessions.

What it helps with

  • catch blank WebGL canvases and failed resource requests
  • compare page rendering in Chromium and WebKit
  • check phone and tablet layouts
  • find horizontal overflow and reduced-motion issues
  • measure frame time and rendering load

Example prompts for the agent

  • Check this 3D page in Chromium and Safari at phone and tablet widths.
  • Capture every view and light state, then create the report and contact sheet.
  • Test the scroll animation and find failed requests.

How to install site-check

1Plugin marketplace

/plugin marketplace add Moh4696/open-3d-skills
/plugin install open-3d-skills@open-3d-skills

This installs the whole open-3d-skills plugin with all its skills

2Skills CLI (Vercel)

npx skills add Moh4696/open-3d-skills --skill site-check -a claude-code

3Manually: put the files in place

~/.claude/skills/site-check/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/site-check/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about site-check

How do I install site-check in Claude Code?

Add the marketplace with /plugin marketplace add Moh4696/open-3d-skills, then install the skill with /plugin install open-3d-skills@open-3d-skills.

What does site-check do?

It tests 3D and animated pages in Chromium and WebKit across viewport sizes and page states. It saves screenshots, a metrics report, and a contact sheet.

What does site-check need to run?

It needs Python 3.9+, the playwright and pillow packages, Playwright browser builds for Chromium and WebKit, and an HTTP server. For three.js renderer counts, the page must expose window.__app.renderer.

Source text

SKILL.md · MIT
---
name: site-check
description: Verifies a 3D or animated web page in real headless browsers before anyone else sees it. Shoots every view, light state and scroll position at desktop, tablet and phone widths in Chromium and WebKit (Safari), measures frame time, draw calls and triangles, catches page errors, failed requests, blank WebGL canvases, horizontal overflow and reduced-motion behaviour, and builds one contact sheet. Use after building or changing any three.js, WebGL, canvas, scroll-driven or animated page, before publishing or recording it, or when someone asks "does it work", "check it on mobile", "why is it slow" or "test it in Safari".
---

# Site check

An animated page can look perfect in the one browser tab it was built in and fail everywhere else: a blank canvas in Safari, a crop on phones, a seam in a scroll film, a 40 ms frame on a laptop. This skill looks at the page the way visitors will, in several real browsers at several sizes, and reports what broke with pictures.

## Tool

`scripts/check.py` drives headless Chromium (on the real GPU) and WebKit through Playwright.

```bash
python3 scripts/check.py http://127.0.0.1:8000/ --out shots \
  --widths 1440,768,390 --browser both \
  --query "view=front" "view=aerial&light=night" \
  --scroll-steps 6 --ready "window.__ready === true"
```

| Option | Meaning |
| --- | --- |
| `--query` | Query strings appended to the URL, each shot at every width. Give pages deep links (`?view=`, `?light=`, `?step=`) so every state is reachable |
| `--widths` | 1440 (laptop), 768 (tablet), 390 (phone, emulated with touch and DPR 2) |
| `--browser` | `chromium`, `webkit` (Safari's engine) or `both` |
| `--scroll-steps N` | Also shoots N evenly spaced scroll positions, for scroll-driven pages |
| `--ready` | JS expression that is true once the page has rendered for real |
| `--wait` | Seconds to let things settle before measuring |

Output: one PNG per shot, `report.json`, and `sheet.jpg` with every shot labelled; problem shots are labelled in red. The script exits 1 if any shot had a page error, a failed or 4xx/5xx request, a blank canvas or horizontal overflow. Each shot also gets a reduced-motion pass at the widest width.

Needs Python 3.9+, `pip install playwright pillow`, and `python3 -m playwright install chromium webkit`. Serve the page over HTTP (ES modules and video seeking need it) with `scripts/serve.py DIR --port 8000`; it answers Range requests, which `python3 -m http.server` does not.

## Reading the report

- **ms per frame** is measured over 60 real frames. Under 16.7 is 60 fps; headless on a laptop GPU should sit near 16.7 (vsync), so a higher number means real cost. Compare runs with each other. If the report says the renderer is SwiftShader or llvmpipe, the GPU was not used and frame times mean nothing.
- **calls / triangles** come from `window.__app.renderer` (three.js), counted for a whole frame including every post-processing pass. Expose the renderer there so the check can see it.
- **ready_s** is how long the page took to set its ready flag. Over 3 s on a fast machine means the loader is visible for too long on a phone.
- **blank canvas** means a visible canvas was one flat colour: a WebGL context that failed, a shader that did not compile in that browser, or a frame drawn before assets loaded.

## Then look

The numbers catch breakage; your eyes catch ugliness. Open `sheet.jpg` and check each shot for:

- The subject cropped or tiny on the phone shot. 3D scenes should widen their vertical field of view on portrait screens; layouts should restack.
- Text over busy imagery without contrast.
- UI covering the subject, or sitting under the phone's home indicator.
- Lighting states that crush to black or clip to white.
- WebKit shots that differ from Chromium: colour (Safari ignores some colour-space hints), missing transparency (VP9 alpha video does not play in Safari), fonts.

## Checks the script cannot do alone

Run these by hand or with `frame-capture` at a low frame rate (`--fps 8`), which is fast and exact:

- **Seams and loops.** Scrub every scroll film up and down fast; watch each join and the wrap of every loop. `scroll-film/scripts/prep.py seams` scores joins numerically.
- **Pins release.** At the end of every pinned section the page must scroll on without a jump.
- **Long sessions.** Leave the page running for a minute, switch light presets back and forth, resize the window a few times; frame time should not creep up (leaked geometries and textures show in `report.json` as rising counts).
- **Throttled first load.** With network throttling, the first paint should be the hero's poster or first frame, not a blank page.
- **Interaction.** Orbit, zoom, hover states, keyboard focus on every control, and touch on a phone.

## Environment traps

- An embedded browser preview that is hidden, or a background tab, throttles or freezes `requestAnimationFrame`. A page that "does not animate" there may be fine. Headless browsers do not have this problem.
- `python3 -m http.server` ignores Range requests, so videos cannot seek and scroll-scrubbed video freezes. Use a server that answers them.
- A missing Playwright browser build after an upgrade: the script falls back to any Chromium in the Playwright cache; `CHROME_PATH` overrides it.

## Report back

Lead with what is broken, ranked by how many visitors it hits: errors and blank canvases first, then phone layout, then Safari differences, then performance, then polish. Attach the contact sheet. Say what was not checked (no real phone, no Windows GPU, no slow network) rather than implying it was.

© exploraX · MIT · Moh4696/open-3d-skills

Similar skills

All skills for Browser and scraping →

From the same set9

exploded-view The exploded-view Claude Code skill builds interactive three.js explainers for machines and products. It animates parts in stages, reveals the casing’s interior, and attaches labels to the model. CX Codex +1 ★ 448repo stars motion-assets The motion-assets skill for Claude Code plans and generates images and video clips for animated websites. It activates for requests to create site visuals, loop a background, or animate an image. CX Codex +1 ★ 448repo stars cursor-rig The cursor-rig Claude Code skill turns an illustration into a portrait that follows the cursor with its head. It’s for adding a reactive character to a page without a 3D model or face tracking. CX Codex +1 ★ 448repo stars alpha-cutout The alpha-cutout Claude Code skill removes a clip’s background and prepares transparent animation for the web. It runs on requests for alpha video or a subject layered over page content. CX Codex +1 ★ 448repo stars frame-capture The frame-capture skill for Claude Code records web pages to MP4 with frame-by-frame control of time. Use it to capture animations, page scrolls, or a comparison of two clips. CX Codex +1 ★ 448repo stars scroll-film The scroll-film Claude Code skill builds film-like page sections controlled by scrolling. It covers clip joins, caption pauses, frame loading and mobile versions. CX Codex +1 ★ 448repo stars threejs-scene This Claude Code skill builds interactive three.js scenes from code, without model files. It activates for 3D websites, WebGL hero sections and real-world objects rendered in 3D. CX Codex +1 ★ 448repo stars open-3d-skills The open-3d-skills Claude Code plugin adds skills for 3D scenes and animated websites. Its eight skills cover three.js builds, scroll-controlled films, and browser checks. CX Codex ★ 448repo stars

Project sponsors

Companies that keep this analytics open