Getting it into your agent
One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.
npx skills add tallesborges/zdx --skill html-artifactsgit clone --depth 1 https://github.com/tallesborges/zdxWrote this? Show the measurements
A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.
[](https://agentmods.dev/skills/tallesborges/zdx/html-artifacts)<a href="https://agentmods.dev/skills/tallesborges/zdx/html-artifacts"><img src="https://agentmods.dev/badge/skills/tallesborges/zdx/html-artifacts/github.svg" alt="Measured on agentmods" height="20"></a>Or the 80×15 button, for a site that already has a row of RSS and ATOM ones. Only the verdict fits; the numbers stay here.
<a href="https://agentmods.dev/skills/tallesborges/zdx/html-artifacts"><img src="https://agentmods.dev/badge/skills/tallesborges/zdx/html-artifacts.svg" alt="Reviewed on agentmods" width="80" height="20"></a>What it costs to keep this loaded
Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.
| Model | Per session | Once invoked |
|---|---|---|
| Fable 5.1 | $0.00109 | $0.02630 |
| Opus 5.5 | $0.00044 | $0.01052 |
| Sonnet 5.5 | $0.00022 | $0.00526 |
| Haiku 4.5 | $0.00011 | $0.00263 |
Grade A, and why
html-artifacts scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 3d ago.
A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.
Nothing flagged
None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.
How it starts
The opening of the file, as written. The whole thing — 115 lines — stays where its author put it; the contents beside it link to each section on GitHub.
HTML artifacts
The user describes a problem: a PR to understand, options to weigh, a workflow to try. HTML pages are how the user explores and thinks through a topic, so the page is often the main result and the chat reply stays short. Your job is to find the visual form that makes the problem clear or lets the user try it, and build it as one HTML page. You choose the form, the structure, and the interaction. The user iterates with annotations.
What the user values
- Visual over prose. The user learns by seeing and trying, so show it when it can be shown.
- Little prose. Short text at the point of use (on a control, beside a figure, in a status) helps; long paragraphs do not. A page that answers a question leads with the answer. A page to operate opens in a working state. Keep evidence, method, and caveats available but out of the way.
- Plain language, per the global Writing Style rule, in the user's language.
- A page that works well on a phone and on a desktop.
- The user's explicit requests win over anything here. When they ask for a format, a library, a layout, or Mermaid, use it.
Stay true to the sources
- Read the sources the task names (threads, files, diffs, notes) instead of working from a summary. Read the thread the task came from when context is missing.
- Show what the sources support. Keep what is measured, inferred, and assumed distinguishable, and do not drop important facts to make the page shorter.
- Use the user's own text verbatim when you show it.
Judgment that tends to work
These are observations, not rules. Choose what fits the problem.
- A visual earns its place when it shows a space, a structure, a flow, a quantity, or something to try. When a sentence is faster, write the sentence.
- Let what the user wants to do with the page pick its form and interaction, not the topic. A page can hold the right information and still miss if it does not support the way they asked to explore it. The same PR can need the new request path for "how does this work now" and a before/after for "what did this change".
- Draw the mechanism, not its name. For options, draw what differs between them.
- An answer that does not depend on the reader's input is often a diagram. A question about amounts is often a chart, a single number, or a table. "What happens if I do X" or "how does this feel" is often a working prototype.
- When the real system has a control, the figure can have it too. Interaction is for exploring the content. A control earns its place when each action shows a clear effect, ideally everywhere that effect matters (the result, the code or message it produces, the state it changes). An empty state says what to try next.
- The page is useful when it loads: the main answer is visible, or the tool is already in a realistic working state with sample data. Nothing important appears only on hover or after an animation.
- A prototype proves the core interaction. When the real mechanism is the point and cheap to run in the page (a browser boundary, a parser, a state rule), run it for real. Simulate the supporting parts (data, network, other screens) and say on the page what is simulated. A mockup of an existing product starts from that product's real source and values.
- SVG is the default for diagrams. Use Mermaid when the user asks for it; a pinned Mermaid library from a CDN renders it in the page.
What this file has done since we first saw it
Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.
- 3d ago First seen · 115 lines · 109 tokens per session scan A 52414095d04e
html-artifacts is a skill published in the GitHub repository tallesborges/zdx (20 stars, last pushed yesterday), licensed MIT. It adds 109 tokens to every session and 2,630 once invoked, about $0.0004 per session on Opus 5.5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-10-25.
Other skills, from other repositories
anti-slop-design
Autonomous Principal Design Technologist. Cures vibe-coded software from AI frontend slop using curated token archetypes and 7-axis quality gating.
chakra-ui-builder
Build responsive, accessible UI components and layouts using Chakra UI v3, install or configure Chakra UI in new and existing projects, and design scalable themes using tokens, semantic tokens, recipes, and slot recipes. Use this skill whenever a user asks to build, create, or generate any UI component, page, form…
visual-ralph
Visual Ralph orchestration for frontend UI from generated references, static references, or live URL targets, using $ultragoal with built-in visual verdict and pixel-diff evidence until the implementation matches and leaves a reproducible design system.
frontend-ui-dark-ts
Build dark-themed React applications using Tailwind CSS with custom theming, glassmorphism effects, and Framer Motion animations. Use when creating dashboards, admin panels, or data-rich interfaces with a refined dark aesthetic.
open-design-setup
Prepare or repair a project's prototyping environment so open-design can build prototypes with the project's own component library and render them through the project's toolchain. Use when the library target is needed and docs/design/prototyping.md is missing, stale, or failing; excludes HTML-only design work and…
frontend-visual-qa
Audits rendered UI and specific task/object-link handoffs; excludes ordinary source citations alone. Audits already-rendered UI and Markdown/Obsidian image layout — web app, deck/slide, dashboard, design-system, or Electron/native app — via real-browser/native-app journeys and a Playwright sweep. Use after UI…