Skip to content
Back to skills

Verify

ASecurity

Visual verification before declaring frontend work done — the screenshot/viewport checklist and the auditOverflow browser probe that finds escaped text, clipped cards, and horizontal scroll the diff never shows.

  • 10 stars
  • 0 votes
  • 0 copies
  • 1 view
  • Added November 13, 2026
developmentgonodefrontend

Works with

  • cli
  • mcp

Security analysis

A100/100

Scanned November 13, 2026

npx -y skills add reliant-labs/forge --skill verify --agent claude-code

Installs into .claude/skills of the current project.

Are you the author of Verify?

Add the live security badge to your README. It updates with every re-scan.

Security grade badge for Verify
[![Security: A — Skills Directory](https://www.skillsdirectory.com/api/skills/reliant-labs-verify/badge)](https://www.skillsdirectory.com/skills/reliant-labs-verify)

More formats (shields.io, HTML) on the badges page. Keep it an A: scan every change in CI with Pro.

Download with Pro
SKILL.md
---
name: verify
description: Visual verification before declaring frontend work done — the screenshot/viewport checklist and the auditOverflow browser probe that finds escaped text, clipped cards, and horizontal scroll the diff never shows.
---

# Verify visually before declaring done

Code that type-checks and tests that pass do not prove a UI looks right. Before reporting visual work complete:

1. Launch the app and load the page you changed (use the `run` skill if available, or the explicit dev-server command).
2. Take a screenshot. Look at it. Compare to the brief (see "Seeing the screenshot" below — taking one is not seeing it).
3. Check at least one other viewport width (mobile if the design is desktop-first, or vice versa).
4. Run the overflow probe below against the changed surface and read the report.
5. Check for overflow / text wrap / alignment regressions in the surrounding area, not just the changed component.

If you cannot run the app, say so explicitly — do not claim visual success based on the diff alone.

## Seeing the screenshot

Taking a screenshot does not mean you saw it. A PNG opened from disk often comes back as metadata only, and some harnesses return an inline screenshot as a text placeholder (`[Image: image/png, 412 KB]`) with no pixels. Either way the review silently degrades to OCR and pixel sampling unless you check:

1. Load the Chrome DevTools tools — they are often deferred: `mcp__chrome-devtools__navigate_page`, `resize_page`, `take_screenshot`, `evaluate_script` (via `load_tool` or your harness's equivalent).
2. `navigate_page` to the dev server URL of the page you changed.
3. `resize_page` to each viewport you check (e.g. 1440×900, 768×1024, 375×812).
4. `take_screenshot` with **no `filePath`** — optionally `fullPage: true`, or a `uid` from `take_snapshot` for one element — so any image comes back in the tool result itself.
5. **Check what you received.** If you can describe what is in it — layout, colours, the actual copy — you saw it: critique it against the brief and the anti-slop blocklist in `frontend/design`. If you got a placeholder, metadata, or nothing you can describe, you did not see it.

When you did not see it, say so plainly. Run the overflow probe plus measurements (`evaluate_script` for rects, computed styles, contrast), report them as **measured, not seen**, and hand the visual judgement to the user: a screenshot saved with `filePath`, or the preview URL. Never claim a visual check you could not see.

## Overflow probe

Headlines that escape their card, captions that wrap into a third line, columns that scroll horizontally on tablet — the diff never shows these. This snippet finds them. Run it in the browser via Chrome DevTools MCP (`mcp__chrome-devtools__evaluate_script`) against the root selector of the surface you changed:

```js
function auditOverflow(rootSelector) {
  const root = document.querySelector(rootSelector);
  if (!root) return { error: `no element matches ${rootSelector}` };

  const cssPath = (el) => {
    const parts = [];
    while (el && el.nodeType === 1 && parts.length < 6) {
      let s = el.tagName.toLowerCase();
      if (el.id) { s += "#" + el.id; parts.unshift(s); break; }
      if (el.className && typeof el.className === "string") {
        const cls = el.className.trim().split(/\s+/).slice(0, 2).join(".");
        if (cls) s += "." + cls;
      }
      parts.unshift(s);
      el = el.parentElement;
    }
    return parts.join(" > ");
  };

  const issues = [];
  const all = [root, ...root.querySelectorAll("*")];

  // (a) element's own content overflows its box
  for (const el of all) {
    if (el.scrollWidth - el.clientWidth > 1) {
      issues.push({ type: "scroll-x", sel: cssPath(el), over: el.scrollWidth - el.clientWidth, text: (el.innerText || "").slice(0, 80) });
    }
    if (el.scrollHeight - el.clientHeight > 1) {
      issues.push({ type: "scroll-y", sel: cssPath(el), over: el.scrollHeight - el.clientHeight, text: (el.innerText || "").slice(0, 80) });
    }
  }

  // (b) descendant's rect escapes a non-`overflow:visible` ancestor's rect
  function walk(el, parent) {
    if (parent) {
      const cr = el.getBoundingClientRect();
      const pr = parent.getBoundingClientRect();
      const cs = getComputedStyle(parent);
      const clipped = cs.overflow !== "visible" || cs.overflowX !== "visible" || cs.overflowY !== "visible";
      const escapes =
        cr.right > pr.right + 0.5 || cr.left < pr.left - 0.5 ||
        cr.bottom > pr.bottom + 0.5 || cr.top < pr.top - 0.5;
      if (escapes && !clipped) {
        issues.push({ type: "escapes-parent", sel: cssPath(el), parent: cssPath(parent), text: (el.innerText || el.tagName).slice(0, 80) });
      }
    }
    for (const c of el.children) walk(c, el);
  }
  walk(root, null);

  return { rootSelector, count: issues.length, issues: issues.slice(0, 40) };
}

auditOverflow("main");  // or a tighter selector for the surface you changed
```

Two classes of finding:

- `scroll-x` / `scroll-y` — an element's own content exceeds its box. Common cause: a long word/URL, a fixed-width child, or a table that doesn't shrink.
- `escapes-parent` — a child's bounding rect extends past an ancestor that isn't clipping. Common cause: absolute positioning gone wrong, negative margins, or a heading that overflows because its container shrank.

Run it at multiple viewports (resize via `mcp__chrome-devtools__resize_page` first) — a layout that's clean at 1440px often falls apart at 768px or 375px.

See also: `frontend/design` for the design rules this verifies against.

Attribution

Is this your skill, or is something wrong with this listing? Request removal or report an issue. Author removals are honored within 72 hours.

View all in development →

Comments

Loading comments…

Newsletter

Get the weekly list of safe new skills, and the ones we pulled.