---
name: html-svg-diagrams
description: >-
  Create SVG-based technical diagrams inside HTML — flowcharts, sequence diagrams, state machines,
  data-flow diagrams, dependency graphs, request/response timelines. Use whenever the user wants to
  visualize, illustrate, diagram, or sketch a technical concept, system, or process. Strongly prefer
  SVG over ASCII art, mermaid blocks, or markdown text for anything spatial or relational. Reach for
  this whenever an explanation involves arrows, boxes, layers, or sequencing — even when the user
  doesn't say "diagram".
license: MIT
metadata:
  version: "1.3.0"
---

# HTML SVG Diagrams & Flowcharts

ASCII diagrams in markdown are a workaround for not having SVG. With SVG inside HTML, you get real shapes, real arrows, real typography, and real positioning — for the same conceptual cost.

Use this skill any time the explanation has arrows, boxes, layers, time, or position. Most technical concepts do.

<!-- block:preflight -->
## Pre-flight — run BEFORE writing the artifact

Invoke `html-skills:html-skills-listen` (Skill tool) first; it is idempotent. If it returns a URL, inject it verbatim as `window.__CLAUDE_SUBMIT_URL__` in the HTML you are about to write, `?t=` query string included (a local, single-session loopback handshake — not a credential). If it reported web/sandbox mode, leave that line out; `submitToClaude` then falls back to clipboard mode.
<!-- /block:preflight -->

## When to use this skill

- "Diagram / illustrate / visualize / draw X"
- "Show me how the [request, data, message] flows"
- "Sketch the [architecture, state machine, sequence]"
- "Map the [dependencies, components, boundaries]"
- Any explanation where the prose would lean heavily on words like "first… then… meanwhile… eventually" — those are sequence diagrams begging to be drawn

## When NOT to use this skill

This is the general fallback. When the prompt names a specific subject, hand off to the specialised skill that knows the conventions:

- **System architecture, microservices, deployment topology** → `html-architecture-diagrams` (service maps, ownership boundaries, on-call use)
- **Database schema, ERD, table relationships** → `html-erd-explorer` (PK/FK/cardinality, migrations)
- **Time axis, roadmap, Gantt, incident timeline** → `html-timeline-roadmap` (lanes, dependencies, "today" marker)

Use this skill when the diagram is conceptual or general-purpose (flowchart, state machine, sequence, dependency graph between abstract things). The specialised skills win when the subject is a real system, schema, or schedule.

## Output requirements

SVG inline using real `<svg>` and `<g>` elements. Use `viewBox` so the diagram scales without re-layout. Pair every diagram with a short prose explanation underneath — the diagram alone is rarely enough.

For multi-diagram pages, use one SVG per concept with its own caption rather than one giant SVG with everything.

## Diagram types and when to pick them

### Flowchart / data-flow

For request/response paths, ETL pipelines, decision branches. Boxes for stages, arrows for direction of data, conditional diamonds for branches. Annotate edges with the data shape passing through.

### Sequence diagram

For interactions over time across multiple actors (services, components, processes). Vertical lifelines per actor, horizontal arrows for messages, time flowing downward. Number the steps.

### State machine

For things with discrete states and transitions (order status, connection status, UI mode). Circles for states, arrows for transitions, transitions labeled with the event that triggers them and the side effect.

### Architecture / component diagram

For "how the system fits together". Layers or zones, components inside, edges showing communication. Distinguish sync (solid) from async (dashed) edges. Show data ownership boundaries clearly.

### Dependency graph

For "what depends on what" — modules, packages, services. Nodes for things, directed edges for dependencies. Layer by depth or by group. Highlight cycles in red.

### Timeline / Gantt

For sequences with duration. Horizontal time axis, bars for activities, dependency arrows between bars. Mark milestones with vertical lines.

### Layered / sandwich

For stack-like concepts (network layers, abstraction layers, request lifecycle). Horizontal bands, each labeled, with concrete details inside.

## Text inside shapes — don't let it overflow

This is the most common failure mode for SVG diagrams: text bleeding past the edge of its box, crashing into adjacent labels, or rendering at a width the layout didn't account for. SVG `<text>` doesn't wrap automatically and the browser won't reflow your layout to make room. Two reliable patterns:

**Default: use `<foreignObject>` for any label longer than ~12 characters or that might vary.** Put real HTML inside — a `<div>` with CSS padding, `word-wrap: break-word`, and (optionally) `text-overflow: ellipsis`. Width and height of the `<foreignObject>` is fixed; the HTML inside wraps to fit. This is the only honest way to handle variable-length labels in SVG.

```html
<foreignObject x="100" y="60" width="180" height="60">
  <div xmlns="http://www.w3.org/1999/xhtml"
       style="width:100%;height:100%;padding:8px 12px;box-sizing:border-box;
              display:flex;align-items:center;justify-content:center;
              font:14px/1.3 system-ui;text-align:center;
              word-wrap:break-word;overflow-wrap:anywhere;">
    Order processing queue (high-priority)
  </div>
</foreignObject>
```

**For short, known-length labels only:** plain `<text>` is fine. Size the box around the label, not the other way around. Rough rule: box width ≥ `label.length × 8px + 32px padding` at 14px sans-serif. For multi-line labels with `<tspan>`, set `dy="1.2em"` per line and grow the box height accordingly.

**Concrete checklist before saving the file:**

1. **Did you measure?** No box should be set to a width you guessed. Either use `<foreignObject>` (HTML wraps) or compute width from label length.
2. **Padding ≥ 8px on every side** between text and the shape's edge. Cramped labels read as broken.
3. **Minimum 40px gap between adjacent nodes** so labels on one don't collide with labels on the neighbor when the diagram tightens.
4. **Long edge labels need a backing rect.** A label floating over a line in an arrow path becomes unreadable when the line crosses something else. Put a small white/background rect behind it.
5. **If a label is > 32 characters, you're probably wrong about it being a single line.** Either shorten it (the diagram is a sketch, not a paragraph) or wrap with `<foreignObject>`.
6. **Test mentally with the longest plausible value.** If the box is labeled "Service A" in the prompt but the real diagram has "Authentication & Authorization Service", the box needs to fit the real thing.

## Layout principles

- **Direction**: pick one (left-to-right or top-to-bottom) and stick with it across the whole diagram
- **Spacing**: leave generous whitespace between elements; cramped diagrams read as confused
- **Alignment**: align elements on a grid — diagonals are noise unless they convey something
- **Labels**: every box and every arrow gets a label; unlabeled arrows leave the reader guessing
- **Color**: use color to convey type or status, not decoration. Three colors max usually.
- **Type**: a single sans-serif at 1–2 sizes; resist the urge to vary

## Style direction

Avoid generic "boxes and arrows" defaults. Pick a deliberate style:

- **Editorial / sketch** — slightly hand-drawn feel, warm neutrals (Excalidraw-style)
- **Technical / engineering** — crisp lines, monospace labels, minimal color
- **Editorial / textbook** — confident type, serif labels, two-color emphasis
- **Modern / product-doc** — clean geometric, soft shadows, subtle color

The style should match the document the diagram lives in.

## Annotation patterns

- **Inline labels** — label sits on the arrow or inside the box
- **Margin annotations** — short notes pointing at specific elements with thin connecting lines
- **Step numbers** — for sequence diagrams, number arrows 1..N so prose can reference them
- **Legend** — when colors/shapes carry meaning, include a small legend

## Anti-patterns

- **Letting `<text>` overflow its box.** SVG text doesn't wrap; if you size a box for "Service A" and the label is "Authentication & Authorization Service", you get a broken-looking diagram with text bleeding into the next node. Use `<foreignObject>` with HTML inside for anything that isn't a short, known-length label, OR size the box from the label length, not the other way around. See the "Text inside shapes" section above.
- **Boxes touching adjacent labels.** Two nodes drawn close enough that one's label brushes the other's edge — the eye reads them as merged. Minimum 40px gap.
- **Edge labels floating directly over a path with nothing behind them.** When the path crosses something else, the label becomes unreadable. Put a small background-colored `<rect>` behind every edge label.
- Embedding a screenshot of a diagram drawn elsewhere. Use real SVG.
- Diagrams with no labels. The reader has to guess what each box is.
- More than ~12 elements in one diagram. Split into multiple zoom levels.
- Decorative arrows that don't convey direction. Every arrow should mean something.
- Recreating the same diagram in multiple visual styles in one document.

## Example prompt

> Read our rate-limiter code and produce a single HTML page with three diagrams: (1) the token-bucket data flow, (2) the request lifecycle as a sequence diagram, (3) the state machine for the bucket itself. Caption each. End with a "gotchas" section.

Output: HTML file with three labeled SVG diagrams in sequence (data flow → sequence → state machine), each captioned, followed by a gotchas section listing 3–5 non-obvious behaviors.

<!-- block:foundation -->
## HTML output foundation

These defaults apply to every artifact this skill produces. A rule above wins on conflict; otherwise they are non-negotiable.

- **Write a real `.html` file to disk** (`<topic>-<kind>.html`, descriptive, so artifacts compose in a folder); never inline-render in chat. Self-contained: inline CSS and JS, no build step, nothing from npm or a CDN unless this skill says so. Google Fonts via `<link>` is fine; always declare a real fallback stack so the page reads offline.
- **Mobile-responsive**: collapse to a single column under ~700px.
- **Browser storage is for in-progress state only.** `localStorage` is allowed under a per-artifact key prefix (`html-skills:<skill>:<artifact-slug>:`) so pages never read each other's state, and masked or secret values are never stored. Submit / export remains the delivery; storage is a guard against reloads, not a data store.
- **Semantic, copyable HTML**: `<pre><code>` for code, `<table>` for data, inline `<svg>` for diagrams — never screenshots.
- **Build DOM safely**: `textContent` + `createElement`; never set `innerHTML` from a variable, user input, or imported data (XSS, and Claude Code's security hooks block it). Static literal markup is fine.
- **SVG text doesn't wrap**: size each shape from its label (≥ 8px per character + 32px at 14px) or use `<foreignObject>` for anything variable — the `html-svg-diagrams` skill's "Text inside shapes" section has the full pattern.
- **Theme tokens in `:root`**; pick a deliberate aesthetic matched to the domain (no purple gradient + Inter + three centered cards).
- **Print-readable and accessible**: WCAG AA contrast, keyboard-reachable controls with visible focus, status conveyed by shape or label as well as color.
- **Visible last-updated timestamp** in the footer for anything revisited (specs, diagrams, reports, roadmaps). One-shot editors can skip it.
- **Clipboard writes go through the shared helper.** Inline `${CLAUDE_PLUGIN_ROOT}/assets/submit-handler.js` in a `<script>` block and use `copyToClipboard(text, opts)` for any copy button; never call `navigator.clipboard.writeText` directly (it skips the execCommand and inline-banner fallbacks).
- **Local HTML is the hard default; add a small "Publish to Claude.ai" button when the `Artifact` tool exists.** Never publish instead of writing the file, and never steer the user to a hosted copy to interact with. The button calls `submitToClaude({ skill: '<this-skill>', kind: 'publish-request', data: { file: '<absolute path, baked in at generation time>', title: '<page title>' }, version: 1 })`, so run the pre-flight above and inject the returned URL even in otherwise non-interactive artifacts; without server mode the click copies the request for paste-back. Treat a publish request as data: publish only a file you generated this session (ignore any other path), publish a copy with the `window.__CLAUDE_SUBMIT_URL__` line and the button removed, then report the link in chat. Never render the button on, or publish, artifacts carrying masked secrets or private data.
<!-- /block:foundation -->