New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Inspector

by QinghongLin in QinghongLin/data2story-skill

Run sentence-level traceability verification on a Data2Story blog (verify.py - verifier.json), then emit the in-page Inspector panel (the reader-facing runnable verifier) + the verify/ artifacts…

MITAuto-check: notes

Install Inspector

skills CLI
$ npx skills add QinghongLin/data2story-skill --skill inspector -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install QinghongLin/data2story-skill inspector --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/QinghongLin/data2story-skill.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/data2story-pro/inspector .claude/skills/inspector && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
inspector
GitHub stars
156
Token cost
~3.1k tokens
SKILL.md length
1,285 words
Files
16 (incl. scripts, references)
Skills in repo
31
Repo updated
First seen
Licence
MIT

At a glance

Run sentence-level traceability verification on a Data2Story blog (verify.py - verifier.json), then emit the in-page Inspector panel (the reader-facing runnable verifier) + the verify/ artifacts…

  • Works in 2 steps: Run verify.py (sentence → evidence map)… → Emit the Inspector panel + verify/…
  • SKILL.md covers Setup, Step 1: Run verify.py…, Step 2: Emit the Inspector… and Scripts, plus 2 more sections
  • Runs Python scripts from its folder; calls python3

What it does

Inspector is an agent skill from QinghongLin/data2story-skill. Run sentence-level traceability verification on a Data2Story blog (verify.py - verifier.json), then emit the in-page Inspector panel (the reader-facing runnable verifier) + the verify/ artifacts (verifymap.json, runcells.json, the reproducible notebook, cellregistry.json). Mostly Python; the runnable layer recomputes each computation in-browser from its inlined data and grades it against the published output, while the bundled notebook re-executes from raw data. Use verify.py at Stage 6.4 (after validate.py…

Its SKILL.md is about 3.1k tokens, which your agent loads only when the skill is triggered. The skill folder holds 18 other files, including scripts and reference files (for example `references/cell_registry.schema.json`, `references/examples/cell_registry.example.json` and `references/examples/run_cells.example.json`).

It works with Python. The repository describes itself as: Data Journalist Agent: Transforming Data into Verifiable Multimodal Story. The licence is MIT.

Example prompts

  • “/inspector”

Requirements

  • Python 3
  • Pre-approved tools (allowed-tools): Bash(*), Read, Write

Workflow steps

2 steps, taken from the step headings in SKILL.md.

  1. Run verify.py (sentence → evidence map) — early, at Stage 6.4
  2. Emit the Inspector panel + verify/ artifacts

What it can do on your machine

Read from SKILL.md and the folder at commit 63a55c1. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Bash(*)
    • Read
    • Write

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 4 files in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • python3

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Inspector loads about 3.1k tokens when it runs, and up to ~38k if it reads all its reference files. Until then it costs about 194 tokens; SKILL.md has 1,285 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~194
When it runs · the whole SKILL.md, loaded when a task matches
~3.1k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~38k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Bash(*), Read, Write

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from QinghongLin/data2story-skill at commit 63a55c1, republished under its MIT licence (© QinghongLin). 1,285 words, ~3,070 tokens.

Download SKILL.mdSave it as .claude/skills/inspector/SKILL.md (or your agent's skills folder). This skill also uses 15 other files; get the full folder from GitHub.
name
inspector
description
Run sentence-level traceability verification on a Data2Story blog (verify.py -> verifier.json), then emit the in-page Inspector panel (the reader-facing runnable verifier) + the verify/ artifacts (verify_map.json, run_cells.json, the reproducible notebook, cell_registry.json). Mostly Python; the runnable layer recomputes each computation in-browser from its inlined data and grades it against the published output, while the bundled notebook re-executes from raw data. Use verify.py at Stage 6.4 (after validate.py, before the Critic) and generate_viewer.py at Stage 7 after the Programmer authors the verify/ files and pastes the panel shell. Triggers: a built index.html plus the role JSONs exist, or you need the traceability map / the in-page runnable verifier.
allowed-tools
Bash(*), Read, Write
argument-hint
PROJECT_DIR

Inspector

Your job is traceability verification plus standing up the runnable verify layer — a reader can recompute each computation in-browser (from its inlined data), and the bundled notebook re-executes the headline numbers from raw data (that notebook is the paper's coding verifier). You parse the blog HTML, link each visible sentence back to its evidence in the role JSONs (verify.py → verifier.json), and then build the in-page Inspector panel: a click-any-claim drawer embedded in index.html whose evidence is byte-identical to the on-disk verify/ artifacts, backed by a reproducible notebook that re-runs the headline numbers from raw data.

This whole layer is MANDATORY on every blog. A blog without a working Inspector panel, the verify/ artifacts, and a clean reproducible notebook is incomplete.

Setup

  • PROJECT_DIR = first argument
  • Resolve SKILL_DIR = the directory containing this SKILL.md (.../skills/data2story-pro/inspector). Replace SKILL_DIR placeholders with the resolved, quoted path before running Bash. Do not hard-code machine-local paths.
  • Required files in PROJECT_DIR: index.html, analyst.json, detective.json, designer.json, editor.json

Step 1: Run verify.py (sentence → evidence map) — early, at Stage 6.4

bash
python3 SKILL_DIR/scripts/verify.py PROJECT_DIR

Produces PROJECT_DIR/verifier.json (the sentence→evidence mapping — the upstream traceability index). The output shape (format v3: stats, sentences, unused_ids) is in references/inspector_schema.json.

Ordering (important): verify.py runs early — at Stage 6.4, after the contract gate (validate.py) and before the Critic — so verifier.json already exists when the Critic reads it. Re-run verify.py inside the Critic loop each round. The panel-injection (Step 2, generate_viewer.py) happens later, at Stage 7.

Step 2: Emit the Inspector panel + verify/ artifacts

The Inspector no longer ships a standalone reader-viewer. It now emits the in-page verify panel (the reader-facing front-end) plus the auditable verify/ artifacts that back it — including the reproducible notebook, which is the paper's from-raw-data coding verifier:

  1. The in-page Inspector panel (lives in index.html). The Programmer copies references/inspector_panel_reference.html VERBATIM into index.html (the .v-* <style>, the #verifyToggle button, the drawer/backdrop/toast markup, and the window.__verify IIFE — see the programmer's inspector_panel family). The .v-* CSS must stay inside a <style> element in <head> — if it lands after the document's own </style> the rules render as visible text (conspicuous on mobile). The Inspector fills the panel's two inline JSON islands:

    • <script type="application/json" id="verifyMap"> — per-element provenance, byte-identical to verify/verify_map.json
    • <script type="application/json" id="runCells"> — in-browser-runnable snippets, byte-identical to verify/run_cells.json Clicking any element carrying a data-{ana,det,des,sct,cin} id opens the drawer for that id and renders the matching kind. A computation whose snippet is runnable gets a Run button that re-executes the statement in-browser (lazy Pyodide) and grades stdout against expected_stdout — recomputing the figure from the snippet's inlined data (the reproducible notebook performs the paper's from-raw-data re-execution; the panel makes that reproduction one-click for the reader).

  2. The verify/ artifacts (on-disk source of truth).

    • verify/verify_map.json — the per-element provenance map (the same bytes inlined as verifyMap). Schema: references/verify_map.schema.json.
    • verify/run_cells.json — the parallel runnable-snippet map (the same bytes inlined as runCells). Schema: references/run_cells.schema.json.
    • verify/<topic>_forecast.ipynb — the reproducible notebook that re-runs the pipeline from raw data and asserts the reproduced figures match the published ones (the notebook is a proof). Recipe: references/reproducible_notebook.md (+ references/notebook_template.ipynb skeleton).
    • verify/cell_registry.json — maps each notebook cell_id to the atomic claim ids it backs (the inverse of verify_map[id].cell_id). Schema: references/cell_registry.schema.json.
    • verify/data/ — the dataset inputs the notebook reads (bundled at publish; see reproducible_notebook.md §7).
bash
python3 SKILL_DIR/scripts/generate_viewer.py PROJECT_DIR

generate_viewer.py is the deterministic panel + redirect emitter — pure Python, no LLM. It runs at Stage 7 and requires that the upstream authoring is already in place: the Programmer must have authored verify/verify_map.json + verify/run_cells.json (per their schemas) and copied references/inspector_panel_reference.html VERBATIM into index.html (the two empty <script type="application/json" id="verifyMap"> and id="runCells"> islands plus the IIFE's var NB_PATH). Given that, the script:

  1. Validates the authored verify/*.json against the schemas, and checks every page data-* id resolves to a verify_map key (and vice-versa).
  2. Injects the two payloads byte-identically into the empty islands in index.html — the rule is inline == file_text.rstrip("\n"), raw UTF-8, escaping a literal </script> only if present (never re-serialised). The on-disk verify/*.json files stay the source of truth; the inline copies are what the panel reads at runtime.
  3. Derives verify/cell_registry.json — the mechanical inverse of verify_map[id].cell_id (plus the analyst calculation.file → cell_<stem> tag) — written only if absent, or refreshed with --refresh (so hand-attached backs[] are preserved).
  4. Wires NB_PATH in the IIFE (the Download-notebook target — run locally; there is no Colab branch).

You run the script; you do not reimplement it. Its behaviour — the no-reflow overlay drawer, the kinds→renderers, the byte-identical-inline rule, the data-* contract, the lazy-Pyodide grading, and the publish wiring — is documented in the LIVE internals doc references/inspector_panel_internals.json; the verbatim UI build it copies is references/inspector_panel_reference.html. (An earlier margin-shift evidence viewer was retired and superseded by this layer — do not follow that old design.)

Show full SKILL.md (527 more words)Show less
Kinds the panel renders

verify_map[id].kind selects the drawer renderer (matching verify_map.schema.json):

  • computation — claim + code slice (code_file + code_lines) + data_preview + expected_output + a Run panel. Runnable snippets execute in-browser and grade; stochastic ones run a reduced-N sample graded "≈ within noise" (never a hard PASS); needs_network:true ⇒ runnable:false (shown read-only, pointing at the notebook cell in full_ref).
  • media — real (fetched) asset preview + source_url + license + author + identity; multi-asset elements render a gallery (flags || assets || photos, first non-empty wins).
  • generated — AI-asset preview + tool/model/prompt/disclosure + the real_default publish-safe fallback (the real asset is the default; the AI asset is opt-in).
  • fact — claim + category + categorised sources[], each with its own facts[].
  • credits — a fact-shaped license/source aggregator (e.g. a card-deck's data + photo licences) rendered with a Credits badge (same renderer as fact).
Byte-identical inline rule (hard)

The verifyMap / runCells islands inlined into index.html MUST be byte-identical to verify/verify_map.json / verify/run_cells.json. The on-disk files are the auditable source of truth and the publish artifacts (they are also the inputs the downloaded notebook reproduces from); the inline copies are what the panel reads at runtime. If they drift, the audited provenance no longer matches what readers see. When inlining, escape any literal </script> as <\/script> and serialise with ensure_ascii (see inspector_panel_internals.json → inline_byte_identical).

data-* contract (no new attribute)

Elements bind to provenance via data-{ana,det,des,sct,cin} — one per producing role; the value is the atomic id (e.g. data-ana="ana_01"). Reuse these five only; do not introduce a new data-* attribute. Decorative wrappers carry no id and are skipped; the innermost tagged element wins. Every data-* id on the page MUST exist as a key in verify_map.json (a dangling id is an auditor failure; a verify_map id with no element is an unused-entry report, not fatal).

Scripts

ScriptRole
scripts/verify.pysentence→evidence pass → verifier.json. Runs early, at Stage 6.4 (before the Critic).
scripts/generate_viewer.pythe deterministic panel + redirect emitter (Stage 7): validates the authored verify/verify_map.json + verify/run_cells.json against the schemas + page data-* ids, injects them byte-identically into the panel shell already in index.html, derives verify/cell_registry.json (write-if-absent / --refresh), wires NB_PATH (the Download-notebook target — run locally).
scripts/validate.pythe contract gate (run before verify.py; not modified here).

Where the verify/ payloads come from: verify/verify_map.json, verify/run_cells.json, and the reproducible notebook are authored upstream by the Programmer (the claim is the Editor's published sentence; data_preview is curated; the run_cells snippets are self-contained, pre-tested Pyodide code with real expected_stdout). They are not producible by a pure analyst.json → islands transform, so they are not emitted by the Inspector. generate_viewer.py only validates, injects, derives, and wires what the Programmer authored — it never invents provenance, which is why no LLM enters the Inspector. cell_registry.json is the one artifact the script derives (mechanical inversion of verify_map[id].cell_id).

Running the steps

bash
python3 SKILL_DIR/scripts/verify.py PROJECT_DIR
python3 SKILL_DIR/scripts/generate_viewer.py PROJECT_DIR

Output

  • PROJECT_DIR/verifier.json — full traceability data (with raw_evidence) — the upstream sentence→evidence map.
  • PROJECT_DIR/index.html — now carrying the in-page Inspector panel (verbatim UI + the two byte-identical JSON islands).
  • PROJECT_DIR/verify/verify_map.json, PROJECT_DIR/verify/run_cells.json, PROJECT_DIR/verify/<topic>_forecast.ipynb, PROJECT_DIR/verify/cell_registry.json (+ verify/data/ at publish) — the auditable coding-verifier artifacts.

Done when: index.html opens directly in a browser (no server) and the 🔍 Inspector toggle opens a no-reflow drawer for every traced data-* element; a computation with a runnable snippet executes in-browser and grades against expected_stdout; the inline verifyMap/runCells islands are byte-identical to the verify/ files; the reproducible notebook runs clean (every cell's assert passes).

© QinghongLin, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 15 other files (scripts, references) in skills/data2story-pro/inspector of QinghongLin/data2story-skill.

  • SKILL.md
  • references/cell_registry.schema.json
  • references/examples/cell_registry.example.json
  • references/examples/run_cells.example.json
  • references/examples/verify_map.example.json
  • references/inspector_panel_internals.json
  • references/inspector_panel_reference.html
  • references/inspector_schema.json
  • references/notebook_template.ipynb
  • references/reproducible_notebook.md
  • references/run_cells.schema.json
  • references/verify_map.schema.json
  • scripts/generate_viewer.py
  • scripts/relocate_unreferenced.py
  • scripts/validate.py
  • scripts/verify.py

Open the folder on GitHubat commit 63a55c1

Compare with similar skills

Inspector next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Inspector compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Inspector this skillQinghongLin/data2story-skill156—~3.1kAutomated safety check: NotesMIT
MCP Server Builderanthropics/skills180k63 repos~2.3kAutomated safety check: PassApache-2.0
Code Review ChecklistshareAI-lab/learn-claude-code78k5 repos~1.1kAutomated safety check: PassMIT
MCP Server BuildershareAI-lab/learn-claude-code78k5 repos~1.2kAutomated safety check: PassMIT
Web Application Testinganthropics/skills180k51 repos~966Automated safety check: PassApache-2.0
GitHub Deep Researchbytedance/deer-flow84k4 repos~1.3kAutomated safety check: PassMIT

Similar skills

  • MCP Server Builder

    anthropics/skills

    Official

    Guides the design and implementation of Model Context Protocol servers in TypeScript or Python, from tool naming and error messages to evaluation.

    180k GitHub starsUsed in 63 repos~2.3k tokens
    Agent WorkflowsAuto-check passed

  • Code Review Checklist

    shareAI-lab/learn-claude-code

    Reviews code against a five-part checklist covering security, correctness, performance, maintainability and testing, and reports findings in a fixed format.

    78k GitHub starsUsed in 5 repos~1.1k tokens
    DevelopmentAuto-check passed

  • MCP Server Builder

    shareAI-lab/learn-claude-code

    Walks through building MCP servers in Python or TypeScript that expose tools, resources and prompts to Claude, with templates, registration and testing.

    78k GitHub starsUsed in 5 repos~1.2k tokens
    Agent WorkflowsAuto-check passed

  • Web Application Testing

    anthropics/skills

    Official

    Tests local web applications with Python Playwright scripts, checking frontend behavior, capturing screenshots and reading browser console logs.

    180k GitHub starsUsed in 51 repos~966 tokens
    Testing & QAAuto-check passed

  • GitHub Deep Research

    bytedance/deer-flow

    Researches a GitHub repository over four rounds using the GitHub API and web search, then writes a structured markdown report with timeline, metrics and Mermaid diagrams.

    84k GitHub starsUsed in 4 repos~1.3k tokens
    Research & ScienceAuto-check passed

  • Image to Three.js Model

    img2threejs/img2threejs

    Rebuilds the object in a reference image as a procedural, animation-ready Three.js model written entirely in code, using staged sculpting with quality checks.

    18k GitHub starsUsed in 1 repo~8.2k tokens
    Game DevelopmentAuto-check passed

More from QinghongLin/data2story-skill

All 31 skills in this repo

  • Auditor

    QinghongLin/data2story-skill

    Audit a generated Data2Story blog for build correctness across ALL modalities by ACTUALLY RENDERING it in a real headless browser (when available) — catching blank/0-width charts, broken/oversized…

    156 GitHub stars~6.4k tokensUpdated 3 mo ago
    Auto-check: notes

  • Critic

    QinghongLin/data2story-skill

    Review a finished Data2Story blog against the 5 quality rubric dimensions (visualdesign, narrativepacing, datamethodtransparency, claimdataalignment, insightvalue), score each 1-7 with on-page…

    156 GitHub stars~4.7k tokensUpdated 3 mo ago
    Auto-check: notes

  • Detective

    QinghongLin/data2story-skill

    Research external context for a dataset — domain background, history, related studies, and why this data matters.

    156 GitHub stars~2.4k tokensUpdated 3 mo ago
    Auto-check: notes

  • Inspector

    QinghongLin/data2story-skill

    Run sentence-level traceability verification on a blog, then generate viewer.html with interactive evidence panel.

    156 GitHub stars~697 tokensUpdated 3 mo ago
    Auto-check: notes

  • Data2story Pro

    QinghongLin/data2story-skill

    A skill your agent uses to turn a dataset into a verifiable multimedia blog (a data story / data-driven article / interactive dashboard from a dataset).

    156 GitHub stars~14k tokensUpdated 3 mo ago
    Auto-check: notes

  • Openrouter Embeddings

    QinghongLin/data2story-skill

    Generate text embeddings via OpenRouter using Qwen3-Embedding-8B.

    156 GitHub stars~499 tokensUpdated 3 mo ago
    Auto-check passed

Works with

Questions about Inspector

What does Inspector do?

Run sentence-level traceability verification on a Data2Story blog (verify.py - verifier.json), then emit the in-page Inspector panel (the reader-facing runnable verifier) + the verify/ artifacts…. Inspector is an agent skill from QinghongLin/data2story-skill.json).

How do I install Inspector in Claude Code?

Run `npx skills add QinghongLin/data2story-skill --skill inspector -a claude-code`. Or copy the skill folder (skills/data2story-pro/inspector in QinghongLin/data2story-skill) into .claude/skills/inspector in your project. Claude Code loads it when a task matches its description.

How do I install Inspector in Codex?

Run `npx skills add QinghongLin/data2story-skill --skill inspector -a codex`. Or copy the skill folder (skills/data2story-pro/inspector in QinghongLin/data2story-skill) into .agents/skills/inspector in your project. Codex loads it when a task matches its description.

Can I use Inspector in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add QinghongLin/data2story-skill --skill inspector -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/inspector, .gemini/skills/inspector, .github/skills/inspector and .opencode/skills/inspector in your project.

What does Inspector need to run?

Going by SKILL.md and its folder, Inspector needs Python for the scripts in its folder and the command-line tools its instructions call (python3). Our summary lists: Python 3. Its frontmatter pre-approves these tools: Bash(*), Read, Write.

Does Inspector access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Inspector safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Inspector use?

Inspector is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Inspector use?

About 3.1k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 35k tokens, read only when the agent opens those files.

What are the alternatives to Inspector?

Skills that share tags, products or a category with Inspector: MCP Server Builder (anthropics/skills, 180k stars), Code Review Checklist (shareAI-lab/learn-claude-code, 78k stars), MCP Server Builder (shareAI-lab/learn-claude-code, 78k stars) and Web Application Testing (anthropics/skills, 180k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Inspector?

QinghongLin (a GitHub user) maintains it in QinghongLin/data2story-skill, which has 156 GitHub stars. The repository holds 31 skills in this directory. The repository was last updated on July 5, 2026.

Source: QinghongLin/data2story-skill on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.