Generated banner for Generative UI
Generated logo for Generative UI

Generative UI

Alex YangCommunityCreated by Alex Yang

  • Skill
  • Tool integration
  • Data and AI
  • MIT
  • No issues found

From the author

Design system and templates for interactive HTML/SVG visuals in Claude and Codex, using an available inline renderer or a standalone HTML file. Use this skill whenever the user wants visual or interactive output rather than plain text or markdown: charts and dashboards, diagrams, flowcharts and architecture drawings, mockups, comparison grids, illustrations, interactive explainers ("explain how X works" with a visual), or tools with sliders, toggles, and live-updating displays — including financial data shown visually and requests phrased as "show me", "visualize", "draw", or "chart this".
— the description by Alex Yang

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

Generative UI provides a structured design system for producing interactive visuals, including charts, diagrams, and data-driven explainers. It defines specific patterns for HTML and SVG content, ensuring that generated widgets maintain a consistent, clean aesthetic that integrates with host environments. The skill includes guidelines for color usage, typography, component styling, and Chart.js integration, enabling the creation of functional, responsive UI elements that support user interaction through sliders, toggles, and prompt-triggering buttons.

What it does

  • Provides templates for interactive charts, flowcharts, and structural diagrams.
  • Defines a design system for consistent typography, spacing, and color usage.
  • Includes guidelines for integrating Chart.js with custom HTML legends.
  • Offers patterns for creating interactive explainers with sliders and live-updating displays.
  • Specifies rules for SVG diagram construction, including node styling and connector paths.
  • Outlines methods for triggering follow-up prompts from within widget elements.

When to use it

  • When you need to present data visually rather than through plain text.
  • When creating interactive explainers that require user input like sliders or toggles.
  • When building diagrams, flowcharts, or architecture drawings for technical explanations.
  • When you need to display financial or categorical data using charts.
  • When you want to create custom UI components that match the host's design language.

Advantages

  • Ensures visual consistency across different types of generated widgets.
  • Provides ready-to-use templates for common visualization tasks.
  • Supports dark and light mode compatibility through CSS variables.
  • Facilitates user interaction by enabling prompt-triggering from within widgets.
  • Reduces visual noise by enforcing a flat, clean design aesthetic.

Usage examples

“Show me a chart of the projected revenue for the next four quarters.”
The agent generates an interactive Chart.js bar chart with a custom HTML legend and metric cards.
“Explain how a load balancer works with a diagram.”
The agent renders an SVG diagram showing the flow of traffic through a load balancer with clickable nodes.
“Visualize the impact of interest rates on a loan.”
The agent creates an interactive widget with a slider to adjust interest rates and a live-updating chart.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/himself65/generative-ui/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip generative-ui.zip -d .agents/skills

Documentation by Alex Yang

Generative UI Skill

This skill contains the complete design system for Claude's built-in show_widget tool — the generative UI feature that renders interactive HTML/SVG widgets inline in claude.ai conversations. The guidelines below are the actual Anthropic "Imagine — Visual Creation Suite" design rules, extracted so you can produce high-quality widgets directly without needing the read_me setup call.

How it works: On claude.ai, Claude has access to the show_widget tool which renders raw HTML/SVG fragments inline in the conversation. This skill provides the design system, templates, and patterns to use it well.

Codex and other hosts: First check the available tools. Use the host's documented visualization interface when provided; otherwise save a complete HTML document in the workspace and return a clickable file link. For standalone output, the fragment-only rule below does not apply: include a document wrapper and viewport metadata, define the CSS variables and SVG classes used by the templates (including dark-mode colors), and load chart dependencies explicitly. The host-specific CDN allowlist and injected styles below describe Claude's renderer; they are not Codex capabilities. Remove chat follow-up buttons and sendPrompt handlers when that bridge is unavailable; keep local sliders and calculations functional. Verify the saved output in a browser when available.


Step 1: Pick the Right Visual Type

Route on the verb, not the noun. Same subject, different visual depending on what was asked:

User saysTypeFormat
"how does X work"Illustrative diagramSVG
"X architecture"Structural diagramSVG
"what are the steps"FlowchartSVG
"explain compound interest"Interactive explainerHTML
"compare these options"Comparison gridHTML
"show revenue chart"Chart.js chartHTML
"create a contact card"Data recordHTML
"draw a sunset"Art/illustrationSVG

Step 2: Build the Widget

Structure (strict order)
<style>  →  HTML content  →  <script>

Output streams token-by-token. Styles must exist before the elements they target, and scripts must run after the DOM is ready.

Philosophy
  • Seamless: Users shouldn't notice where the host UI ends and your widget begins

  • Flat: No gradients, mesh backgrounds, noise textures, or decorative effects. Clean flat surfaces

  • Compact: Show the essential inline. Explain the rest in text

  • No stock "AI design" defaults: skip cream or off-white panels, italic accent words in headings, numbered "01 / 02 / 03" section labels, monospace labels outside code, and pill-shaped buttons — they read as generic and clash with the host UI

  • Text goes in your response, visuals go in the tool — write explanatory text, descriptions, and summaries as normal response text outside the tool call; the widget holds only the visual element

Core Rules
  • No <!-- comments --> or /* comments */ (waste tokens, break streaming)

  • No font-size below 11px

  • No emoji — use CSS shapes or SVG paths

  • No gradients, drop shadows, blur, glow, or neon effects

  • No dark/colored backgrounds on outer containers (transparent only — host provides the bg)

  • Typography: two weights only: 400 regular, 500 medium. Never use 600 or 700. Headings: h1=22px, h2=18px, h3=16px — all font-weight 500. Body text=16px, weight 400, line-height 1.7

  • Sentence case always. Never Title Case, never ALL CAPS

  • No mid-sentence bolding — entity names go in code style not bold

  • No <!DOCTYPE>, <html>, <head>, or <body> — just content fragments

  • No position: fixed — use normal-flow layouts

  • No tabs, carousels, or display: none sections during streaming

  • No nested scrolling — auto-fit height

  • Corners: border-radius: var(--border-radius-lg) for cards, var(--border-radius-md) for elements

  • No rounded corners on single-sided borders (border-left, border-top)

  • Round every displayed number — use Math.round(), .toFixed(n), or Intl.NumberFormat

CDN Allowlist (CSP-enforced)

External resources may ONLY load from:

  • cdnjs.cloudflare.com

  • cdn.jsdelivr.net

  • unpkg.com

  • esm.sh

All other origins are blocked — the request silently fails.

CSS Variables

Backgrounds: --color-background-primary (white), -secondary (surfaces), -tertiary (page bg), -info, -danger, -success, -warning Text: --color-text-primary (black), -secondary (muted), -tertiary (hints), -info, -danger, -success, -warning Borders: --color-border-tertiary (0.15α, default), -secondary (0.3α, hover), -primary (0.4α), semantic -info/-danger/-success/-warning Typography: --font-sans, --font-serif, --font-mono Layout: --border-radius-md (8px), --border-radius-lg (12px), --border-radius-xl (16px)

All auto-adapt to light/dark mode.

Dark mode is mandatory — every color must work in both modes:

  • In HTML: always use CSS variables for text. Never hardcode colors like color: #333

  • In SVG: use pre-built color classes (c-blue, c-teal, etc.) — they handle light/dark automatically

  • Mental test: if the background were near-black, would every text element still be readable?

sendPrompt(text)

A global function that sends a message to chat as if the user typed it. Use it when the user's next step benefits from Claude thinking. Handle filtering, sorting, toggling, and calculations in JS instead.


Step 3: Render with the Available Host

When the host exposes show_widget, pass your widget code directly as below. In Codex without that tool, follow the standalone HTML path above; do not invent a show_widget call.

{
  "title": "snake_case_widget_name",
  "widget_code": "<style>...</style>\n<div>...</div>\n<script>...</script>"
}
ParameterTypeRequiredDescription
titlestringYesSnake_case identifier for the widget
widget_codestringYesHTML or SVG code. For SVG: start with <svg>. For HTML: content fragment

For SVG output: start widget_code with <svg — it will be auto-detected and wrapped appropriately.


Step 4: Chart.js Template

For charts, use onload callback pattern to handle script load ordering:

<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(140px, 1fr)); gap: 12px;">
  <div style="background: var(--color-background-secondary); border-radius: var(--border-radius-md); padding: 1rem;">
    <div style="font-size: 13px; color: var(--color-text-secondary);">Label</div>
    <div style="font-size: 24px; font-weight: 500;" id="stat1">—</div>
  </div>
</div>

<div style="position: relative; width: 100%; height: 300px; margin-top: 1rem;">
  <canvas id="myChart"></canvas>
</div>

<div style="display: flex; align-items: center; gap: 12px; margin-top: 1rem;">
  <label style="font-size: 14px; color: var(--color-text-secondary);">Parameter</label>
  <input type="range" min="0" max="100" value="50" id="param" step="1" style="flex: 1;" />
  <span style="font-size: 14px; font-weight: 500; min-width: 32px;" id="param-out">50</span>
</div>

<script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/4.5.1/chart.umd.js" onload="initChart()"></script>
<script>
function initChart() {
  const slider = document.getElementById('param');
  const out = document.getElementById('param-out');
  let chart = null;

  function update() {
    const val = parseFloat(slider.value);
    out.textContent = val;
    document.getElementById('stat1').textContent = val.toFixed(1);

    const labels = [], data = [];
    for (let x = 0; x <= 100; x++) {
      labels.push(x);
      data.push(x * val / 100);
    }

    if (chart) chart.destroy();
    chart = new Chart(document.getElementById('myChart'), {
      type: 'line',
      data: { labels, datasets: [{ data, borderColor: '#7F77DD', borderWidth: 2, pointRadius: 0, fill: false }] },
      options: {
        responsive: true,
        maintainAspectRatio: false,
        plugins: { legend: { display: false } },
        scales: { x: { grid: { display: false } } }
      }
    });
  }

  slider.addEventListener('input', update);
  update();
}
if (window.Chart) initChart();
</script>

Chart.js rules:

  • Canvas cannot resolve CSS variables — use hardcoded hex

  • Set height ONLY on the wrapper div, never on canvas itself

  • Always responsive: true, maintainAspectRatio: false

  • Always disable default legend, build custom HTML legends

  • Number formatting: -$5M not $-5M (negative sign before currency symbol)

  • Use onload="initChart()" on CDN script tag + if (window.Chart) initChart(); as fallback


Step 5: SVG Diagram Template

For flowcharts and diagrams, use SVG with pre-built classes:

<svg width="100%" viewBox="0 0 680 H">
  <defs>
    <marker id="arrow" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">
      <path d="M2 1L8 5L2 9" fill="none" stroke="context-stroke" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
    </marker>
  </defs>

  <!-- Single-line node (44px tall) -->
  <g class="node c-blue" onclick="sendPrompt('Tell me more about this')">
    <rect x="250" y="40" width="180" height="44" rx="8" stroke-width="0.5"/>
    <text class="th" x="340" y="62" text-anchor="middle" dominant-baseline="central">Step one</text>
  </g>

  <!-- Connector arrow -->
  <line x1="340" y1="84" x2="340" y2="120" class="arr" marker-end="url(#arrow)"/>

  <!-- Two-line node (56px tall) -->
  <g class="node c-teal" onclick="sendPrompt('Explain this step')">
    <rect x="230" y="120" width="220" height="56" rx="8" stroke-width="0.5"/>
    <text class="th" x="340" y="140" text-anchor="middle" dominant-baseline="central">Step two</text>
    <text class="ts" x="340" y="158" text-anchor="middle" dominant-baseline="central">Processes the input</text>
  </g>
</svg>

SVG rules:

  • ViewBox always 680px wide (viewBox="0 0 680 H"). Set H to fit content + 40px padding

  • Safe area: x=40 to x=640, y=40 to y=(H-40)

  • Pre-built classes: t (14px), ts (12px secondary), th (14px medium 500), box, node, arr, c-{color}

  • Every <text> element must carry a class (t, ts, or th)

  • Use dominant-baseline="central" for vertical text centering in boxes

  • Connector paths need fill="none" (SVG defaults to fill: black)

  • Stroke width: 0.5px for borders and edges

  • Make all nodes clickable: onclick="sendPrompt('...')"


Step 6: Interactive Explainer Template

For interactive explainers (sliders, live calculations, inline SVG):

<div style="display: flex; align-items: center; gap: 12px; margin: 0 0 1.5rem;">
  <label style="font-size: 14px; color: var(--color-text-secondary);">Years</label>
  <input type="range" min="1" max="40" value="20" id="years" style="flex: 1;" />
  <span style="font-size: 14px; font-weight: 500; min-width: 24px;" id="years-out">20</span>
</div>

<div style="display: flex; align-items: baseline; gap: 8px; margin: 0 0 1.5rem;">
  <span style="font-size: 14px; color: var(--color-text-secondary);">$1,000 →</span>
  <span style="font-size: 24px; font-weight: 500;" id="result">$3,870</span>
</div>

<div style="margin: 2rem 0; position: relative; height: 240px;">
  <canvas id="chart"></canvas>
</div>

<script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/4.5.1/chart.umd.js" onload="initChart()"></script>
<script>
function initChart() {
  // slider logic, chart rendering, sendPrompt() for follow-ups
}
if (window.Chart) initChart();
</script>

Use sendPrompt() to let users ask follow-ups: sendPrompt('What if I increase the rate to 10%?')


Step 7: Respond to the User

After rendering the widget, briefly explain:

  1. What the widget shows

  2. How to interact with it (which controls do what)

  3. One key insight from the data

Keep it concise — the widget speaks for itself.


Reference Files

  • references/design_system.md — Complete color palette (9 ramps × 7 stops), CSS variables, UI component patterns, metric cards, layout rules

  • references/svg_and_diagrams.md — SVG viewBox setup, font calibration, pre-built classes, flowchart/structural/illustrative diagram patterns with examples

  • references/chart_js.md — Chart.js configuration, script load ordering, canvas sizing, legend patterns, dashboard layout

Read the relevant reference file when you need specific design tokens, SVG coordinate math, or Chart.js configuration details.

Files

references/svg_and_diagrams.md

SVG Setup and Diagram Patterns

Extracted from Claude's actual visualize:read_me guidelines.


SVG Setup

ViewBox: <svg width="100%" viewBox="0 0 680 H"> — 680px wide, flexible height. Set H to fit content tightly (last element's bottom edge + 40px padding). Safe area: x=40 to x=640, y=40 to y=(H-40). Background transparent.

The 680 in viewBox is load-bearing — do not change it. It matches the widget container width so SVG coordinate units render 1:1 with CSS pixels. If your diagram content is naturally narrow, keep viewBox width at 680 and center the content — do not shrink the viewBox.

Do not wrap the SVG in a container <div> with a background color — the widget host provides the card container and background. Output the raw <svg> element directly.

ViewBox Safety Checklist

Before finalizing any SVG, verify:

  1. Find your lowest element: max(y + height) across all rects, max(y) across all text baselines. Set viewBox height = that value + 40px buffer

  2. Find your rightmost element: max(x + width) across all rects. All content must stay within x=0 to x=680

  3. For text with text-anchor="end", the text extends LEFT from x. If x=118 and text is 200px wide, it starts at x=-82 — outside the viewBox

  4. Never use negative x or y coordinates. The viewBox starts at 0,0

  5. For every pair of boxes in the same row, check that left box's (x + width) < right box's x by at least 20px

Font Size Calibration
TextCharsWeightSizeRendered Width
Authentication Service2250014px167px
Background Job Processor2450014px201px
Detects and validates incoming tokens3740014px279px
forwards request to1940012px123px

Before placing text in a box: does (text width + 2×padding) fit the container? Box width formula: rect_width = max(title_chars × 8, subtitle_chars × 7) + 24.

SVG <text> never auto-wraps. Every line break needs an explicit <tspan x="..." dy="1.2em">.

Pre-built Classes

Already loaded in SVG widget context:

  • class="t" = sans 14px primary text

  • class="ts" = sans 12px secondary text

  • class="th" = sans 14px medium (500) heading text

  • class="box" = neutral rect (bg-secondary fill, border stroke)

  • class="node" = clickable group with hover effect (cursor pointer, slight dim on hover)

  • class="arr" = arrow line (1.5px, open chevron head)

  • class="leader" = dashed leader line (tertiary stroke, 0.5px, dashed)

  • class="c-{ramp}" = colored node. Apply to <g> or shape element (rect/circle/ellipse), NOT to paths. Sets fill+stroke on shapes, auto-adjusts child text classes, dark mode automatic

  • Short aliases: var(--p), var(--s), var(--t), var(--bg2), var(--b)

c-{ramp} nesting: These classes use direct-child selectors. Nest a <g> inside a <g class="c-blue"> and inner shapes become grandchildren — they lose the fill and render BLACK. Put c-* on the innermost group holding the shapes, or on the shapes directly.

Arrow Marker (always include)
<defs>
  <marker id="arrow" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">
    <path d="M2 1L8 5L2 9" fill="none" stroke="context-stroke" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
  </marker>
</defs>

Use marker-end="url(#arrow)" on lines. The head uses context-stroke — inherits the color of whichever line it sits on.

Style Rules
  • Every <text> element must carry one of: t, ts, th

  • Use only two font sizes: 14px (node labels) and 12px (subtitles, descriptions, arrow labels)

  • No decorative step numbers or oversized headings

  • No icons or illustrations inside boxes — text only

  • Sentence case on all labels

  • Stroke width: 0.5px for diagram borders and edges

  • Connector paths need fill="none" (SVG defaults to fill: black)

  • rx="4" for subtle corners, rx="8" max for emphasized rounding

  • One SVG per tool call — never leave an abandoned or partial SVG


Diagram Types

Flowchart

For sequential processes, cause-and-effect, decision trees.

Planning: Size boxes to fit text generously. At 14px, each character is ~8px wide. A label like "Load Balancer" (13 chars) needs at least 140px wide rect.

Spacing: 60px minimum between boxes, 24px padding inside boxes, 12px between text and edges. Leave 10px gap between arrowheads and box edges. Two-line boxes need at least 56px height with 22px between lines.

Vertical text placement: Every <text> inside a box needs dominant-baseline="central", with y set to the center of its slot. Formula: for text centered in a rect at (x, y, w, h), use <text x={x+w/2} y={y+h/2} text-anchor="middle" dominant-baseline="central">.

Layout: Prefer single-direction flows. Max 4-5 nodes per diagram. The widget is narrow (~680px).

Single-line node (44px tall):

<g class="node c-blue" onclick="sendPrompt('Tell me more about T-cells')">
  <rect x="100" y="20" width="180" height="44" rx="8" stroke-width="0.5"/>
  <text class="th" x="190" y="42" text-anchor="middle" dominant-baseline="central">T-cells</text>
</g>

Two-line node (56px tall):

<g class="node c-blue" onclick="sendPrompt('Tell me more about dendritic cells')">
  <rect x="100" y="20" width="200" height="56" rx="8" stroke-width="0.5"/>
  <text class="th" x="200" y="38" text-anchor="middle" dominant-baseline="central">Dendritic cells</text>
  <text class="ts" x="200" y="56" text-anchor="middle" dominant-baseline="central">Detect foreign antigens</text>
</g>

Connector (no label):

<line x1="200" y1="76" x2="200" y2="120" class="arr" marker-end="url(#arrow)"/>

Arrows: Must not cross any other box or label. If the direct path crosses something, route around with an L-bend: <path d="M x1 y1 L x1 ymid L x2 ymid L x2 y2"/>.

Cycles: Don't draw as rings. Build a stepper in HTML instead: one panel per stage, dots showing position (● ○ ○), Next wraps from last stage to first.

Over budget prompts: If user lists 6+ components, decompose into a stripped overview + one diagram per interesting sub-flow, each with 3-4 nodes.

Structural Diagram

For concepts where physical or logical containment matters.

Container rules:

  • Outermost: large rounded rect, rx=20-24, lightest fill (50 stop), 0.5px stroke (600 stop). Label at top-left, 14px bold

  • Inner regions: medium rounded rects, rx=8-12, next shade fill (100-200 stop). Different color ramp if semantically different

  • 20px minimum padding inside every container

  • Max 2-3 nesting levels

Example (horizontal layout with two inner regions):

<defs>
  <marker id="arrow" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">
    <path d="M2 1L8 5L2 9" fill="none" stroke="context-stroke" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
  </marker>
</defs>
<g class="c-green">
  <rect x="120" y="30" width="560" height="260" rx="20" stroke-width="0.5"/>
  <text class="th" x="400" y="62" text-anchor="middle">Library branch</text>
  <text class="ts" x="400" y="80" text-anchor="middle">Main floor</text>
</g>
<g class="c-teal">
  <rect x="150" y="100" width="220" height="160" rx="12" stroke-width="0.5"/>
  <text class="th" x="260" y="130" text-anchor="middle">Circulation desk</text>
  <text class="ts" x="260" y="148" text-anchor="middle">Checkouts, returns</text>
</g>
<g class="c-amber">
  <rect x="450" y="100" width="210" height="160" rx="12" stroke-width="0.5"/>
  <text class="th" x="555" y="130" text-anchor="middle">Reading room</text>
  <text class="ts" x="555" y="148" text-anchor="middle">Seating, reference</text>
</g>
<text class="ts" x="410" y="175" text-anchor="middle">Books</text>
<line x1="370" y1="185" x2="448" y2="185" class="arr" marker-end="url(#arrow)"/>

Color in structural diagrams: Nested regions need distinct ramps. Same class on parent and child gives identical fills and flattens the hierarchy. Pick a related ramp for inner structures and a contrasting ramp for functionally different regions.

Database schemas / ERDs: Use mermaid.js, not SVG.

Illustrative Diagram

For building intuition. Draw the mechanism, not a diagram about the mechanism.

Two flavors:

  • Physical subjects: simplified cross-sections, cutaways, schematics (a water heater is a tank with a burner)

  • Abstract subjects: spatial metaphors (a transformer is stacked slabs with attention threads, a hash function is a funnel scattering into buckets)

What changes from flowchart rules:

  • Shapes are freeform: <path>, <ellipse>, <circle>, <polygon>, curved lines

  • Layout follows the subject's geometry, not a grid

  • Color encodes intensity, not category (warm = active/high-weight, cool = dormant)

  • Layering and overlap are encouraged for shapes (but never let a stroke cross text)

  • Small shape-based indicators are allowed (triangles for flames, circles for bubbles)

  • One gradient per diagram is permitted — only for continuous physical properties

  • CSS @keyframes animation permitted (only transform and opacity, wrap in @media (prefers-reduced-motion: no-preference))

Prefer interactive over static: if the real-world system has a control, give the diagram that control. Use show_widget with inline SVG + HTML controls.

Label placement: Place labels outside the drawn object with thin leader lines (0.5px dashed). Reserve at least 140px of horizontal margin on the label side.

Composition approach:

  1. Main object's silhouette — largest shape, centered

  2. Internal structure: chambers, pipes, membranes

  3. External connections: pipes, arrows, input/output labels

  4. State indicators last: color fills, small animated elements

  5. Leave generous whitespace around the object for labels

Routing Decisions
User saysTypeWhat to draw
"how do LLMs work"IllustrativeToken row, stacked layers, attention threads
"transformer architecture"StructuralLabelled boxes: embedding, attention, FFN
"how does attention work"IllustrativeOne query token, fan of lines to every key
"what are the training steps"FlowchartForward → loss → backward → update
"explain the Krebs cycle"HTML stepperClick through stages. Never a ring
"draw the database schema"mermaid.jserDiagram syntax

The illustrative route is the default for "how does X work" — don't default to a flowchart because it feels safer.


Art and Illustration

For "draw me a sunset" / "create a geometric pattern":

  • Fill the canvas — art should feel rich, not sparse

  • Bold colors: mix --color-text-* categories for variety

  • Art is the one place custom <style> color blocks are fine — freestyle colors

  • Layer overlapping opaque shapes for depth

  • Organic forms with <path> curves, <ellipse>, <circle>

  • Texture via repetition (parallel lines, dots, hatching) not raster effects

  • Geometric patterns with <g transform="rotate()"> for radial symmetry

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Node.js

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Alex Yang
Publisher
Alex Yang (Community)
Source
himself65/finance-skills · plugins/ui-tools/skills/generative-ui · commit a085078
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Alex Yang or Alex Yang.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download generative-ui.zip