UI Illustrations

ui-illustrations — Illustration and imagery for product UIs

Overview

Sources, brands, integrates, and ships illustration in web application UIs. The center of gravity is the data-dense product tool that today shows bare text where imagery would carry warmth and clarity — empty states, onboarding, and error pages — without tipping into decoration. The skill covers the placement doctrine (where imagery helps vs clutters), the free-library sourcing landscape with its license traps, recoloring sourced SVGs to design tokens so one asset follows both themes, correct SVG-in-React integration, animated imagery done accessibly, and the craft of a good empty state. It sources and integrates existing illustration; it does not teach drawing original art.

When to activate

• ✅ A screen shows a bare "No items yet" (or worse, nothing) and needs a real empty state.
• ✅ Adding onboarding/first-run, error-page (404/500/permission), or success-moment imagery.
• ✅ Choosing an illustration source, checking whether attribution is required, or matching sourced art to the app's palette and dark mode.
• ✅ Embedding an SVG or Lottie file in a React codebase and wiring its accessibility.

Do NOT activate when:

• Icons are the need — icon systems (lucide, Heroicons) are a separate asset class with their own conventions.
• UI element/interaction motion is the need (transitions, micro-interactions) — a motion-implementation skill owns that; this skill owns imagery, including animated imagery files.
• Original illustration must be drawn or a full illustration design language authored — that is designer/vendor work; this skill selects and integrates.
• Marketing-site hero/photography art direction.

Workflow

Step 1: Placement — does imagery belong here at all?

Proportionality: an ops/admin tool wants restraint — a handful of consistent illustrations at the placements above; a consumer product tolerates more. If the illustration carries no message the adjacent text doesn't already carry, cut it.

Step 2: Source — the decision path

1. Default: unDraw. One consistent style across hundreds of concepts, on-site primary-color customization, and a permissive license: commercial use and modification allowed, no attribution required. Its main prohibitions are redistributing the assets as packs/competing collections and using them for AI-model training.
2. Animated: LottieFiles free tier (Lottie Simple License) — commercial use, modification, no required attribution (credit encouraged); modifications are share-alike (derivatives redistribute under the same license); no compiling the files into a competing collection. Storyset (Freepik) for animated/richer SVG scenes — free tier requires visible attribution ("Designed by Freepik" + link, clearly findable); a paid Freepik-company subscription removes it (which tier the terms name has drifted — confirm on the live terms at adoption); no resale/redistribution or trademark/logo use.
3. Record the license at adoption. Terms drift (the table above is a dated snapshot — forged 2026-07-11); re-check the source's live license page when adopting, and record source URL + license + date next to the asset (a assets/illustrations/LICENSES.md works). An attribution obligation is a shipping requirement, not a footnote.
4. AI-generated illustration exists as an option; its caveats — style drift across generations and licensing ambiguity — make it a deliberate choice, not the default.

Step 3: Keep one style family

Style consistency beats volume: 5 illustrations from one family read as designed; 50 mixed ones read as clip-art. Hold constant across every illustration in the product: geometric-vs-organic, flat-vs-dimensional, line treatment, detail level, and (for character art) proportions and diversity. Practically: pick one library/family in Step 2 and stay in it; when a concept is missing, choose the nearest in-family metaphor rather than importing an off-family asset.

Step 4: Brand-match — recolor to tokens

• Quick path: unDraw's on-site color picker sets the accent to your primary before download.
• Durable path: inline the SVG and replace hardcoded fills with semantic tokens — fill="#6c63ff" → fill: var(--primary) (style attribute or CSS) — so the SAME asset follows theme switches, including dark mode. Keep skin tones and true neutrals literal; tokenize accents, clothing, objects, and background shapes.
• Details in references/svg-integration-and-theming.md (incl. the three dark-mode strategies — most light-theme art breaks on dark backgrounds unaltered).

Step 5: Integrate correctly

• Inline component (Vite: import Art from "./empty.svg?react" via the SVGR plugin) when you need token recoloring or a11y control from CSS/React.
• <img src> (import artUrl from "./empty.svg?url") for larger static art: cacheable, lazy-loadable (loading="lazy"), no CSS reach inside.
• Always prevent layout shift: the SVG keeps its viewBox, and the slot has explicit dimensions or aspect-ratio.
• Bundle discipline: inlined SVG ships in the JS bundle — inline the small above-the-fold empty-state art, img+lazy the rest.
• Full decision table + Lottie embedding: references/svg-integration-and-theming.md.

Step 6: Accessibility defaults

• Empty-state/decorative art: aria-hidden="true" (inline) or alt="" (img) — the adjacent heading/text carries the message. An image that itself informs gets real alt text.
• Animated imagery must respect prefers-reduced-motion (render the static first frame) and, if the auto-playing motion runs longer than 5 seconds total (looping or not), needs a pause control (WCAG 2.2.2).
• Contract details + the empty-state anatomy and variants: references/empty-states-and-a11y.md.

Rules

Hard rules (never violate):

• Check the license before shipping an asset; record source + license + date next to the asset. Ship required attribution visibly (Storyset free tier) or don't ship the asset.
• No imagery on persistent data surfaces — empty states, onboarding, errors, and success moments only, unless the owner explicitly directs otherwise.
• One style family per product.
• Decorative imagery is hidden from assistive tech (aria-hidden/empty alt); informative imagery gets real alternative text.
• Animated imagery respects reduced motion — static fallback under prefers-reduced-motion, pause control for auto-playing motion >5 s total.
• Never redistribute sourced assets as collections — every listed source prohibits it; use within your product only.

Preferences (override-able):

• unDraw as the default source; Storyset/Lottie when animation earns its place.
• Illustration supports, never dominates: cap empty-state art around 160–240 px tall on desktop, smaller on mobile.
• Tokenized recolor over per-theme asset pairs when the art allows it.

Gotchas

• Storyset's attribution is a real obligation — "free" there means attribution-required; hiding the credit in a footer nobody can find fails the terms. unDraw and Lottie-Simple-License assets need none.
• Light-theme art breaks silently on dark mode: baked-in white shapes glow, dark strokes vanish. Audit every illustration in both themes; fix via tokenized fills or per-theme pairs — an untouched sourced SVG is almost never dark-safe.
• The SVG's own <title> leaks: many downloaded SVGs carry a <title> ("undraw_empty_4zx0") — AT announces it when aria-hidden is forgotten, and browsers show it as a hover tooltip regardless; strip it (or make it meaningful) when inlining, in addition to aria-hidden.
• CLS from missing dimensions: an SVG without reserved space pops the layout when it loads (especially img + lazy). Reserve the slot.
• Inlining everything bloats the bundle: a 40 kB illustration inlined into a shared chunk ships to every route. Inline only what needs CSS reach; ?url the rest.
• currentColor is not a palette: it recolors monochrome glyphs, not multi-color illustrations — those need explicit token substitution per fill.
• Lottie share-alike: a modified Lottie-Simple-License animation redistributes under the same license — fine inside your app, a trap if you publish asset packs.

Anti-patterns

• "Add illustrations everywhere — it looks friendly." Placement doctrine first; imagery without a message is clutter, and data surfaces stay clean.
• "It's free, just use it." Free tiers differ exactly on the obligation that bites (attribution); check and record the license.
• "Mix the best illustration from each library." Style-family consistency beats per-asset quality.
• "Ship now, dark-mode the art later." Later means a visual bug report; audit both themes at integration time.
• "It's just decorative, skip the a11y attributes." Decorative is an a11y decision you implement (aria-hidden/alt=""), not one you skip.

Output

Illustrated UI surfaces in a React codebase: sourced, license-recorded assets under the project's asset convention; empty states/onboarding/error pages carrying consistent, token-recolored, theme-safe, accessible imagery; animated imagery gated on reduced motion. Consumers are the codebase's reviewers and the design-system doc, which records the product's chosen family and placement rules.

Related

• A motion-implementation skill (Motion for React) owns UI element/interaction animation and the reduced-motion contract this skill's animated-imagery rules reference; imagery files (incl. Lottie) are owned here.
• An icon-system convention (lucide et al.) owns icons — a separate asset class.
• A design-system skill/doc records which family, tokens, and placements THIS product locked; this skill is the portable how-to it applies.
• A component-styling skill (Radix/Tailwind) owns the components the imagery sits in.

Progressive disclosure

• references/sourcing-and-licensing.md — load when picking a source, checking terms, or handling attribution/generated-art questions.
• references/svg-integration-and-theming.md — load when embedding SVGs (inline vs img vs Lottie), recoloring to tokens, or fixing dark mode.
• references/empty-states-and-a11y.md — load when building empty states/onboarding/ error pages or wiring imagery accessibility.
• references/sources.md — research provenance; load only when auditing claims.

Body budget

• description ≤ 1,024 chars (agentskills.io cap).
• Body ≤ ~500 lines / 5,000 tokens soft target; overflow lives in references/.