Agent skill

Interface Kit

by JuliusBrussee in JuliusBrussee/skills

Authoritative guide for implementing stunning, accessible, performant UI.

MITAuto-check passedFrontend & Design

Install Interface Kit

skills CLI
$ npx skills add JuliusBrussee/skills --skill interface-kit -a claude-code

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

GitHub CLI
$ gh skill install JuliusBrussee/skills interface-kit --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/JuliusBrussee/skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/interface-kit .claude/skills/interface-kit && 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
interface-kit
GitHub stars
161
Used in
1 other repo
Token cost
~5.3k tokens
SKILL.md length
2,166 words
Files
5 (incl. references)
Skills in repo
6
Repo updated
First seen
Licence
MIT

At a glance

Authoritative guide for implementing stunning, accessible, performant UI.

  • Works in 10 steps: Core Philosophy → The Priority Stack → Aesthetic Direction → …
  • Phrases: build UI
  • SKILL.md covers 1. Core Philosophy, 2. The Priority Stack, 3. Aesthetic Direction and 4. Typography Essentials, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Interface Kit is an agent skill from JuliusBrussee/skills. Authoritative guide for implementing stunning, accessible, performant UI. Synthesizes design engineering philosophy, accessibility standards, animation principles, spatial design, typography, color systems, and component craft into a single actionable reference. Complements the design-system skill (which covers DESIGN.md spec writing) by covering the HOW of implementation. Trigger phrases: "build UI", "create component", "landing page", "make it look good", "frontend", "design", "polish UI", "implement design"…

Its SKILL.md is about 5.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including reference files (for example `references/accessibility-checklist.md`, `references/animation-playbook.md` and `references/component-patterns.md`).

It sits in Frontend & Design, covering Typography, Design tokens and Design systems. The licence is MIT.

When your agent uses it

  • Phrases: build UI
  • Create component
  • Make it look good
  • Implement design

Example prompts

  • “build UI”
  • “create component”
  • “landing page”
  • “/interface-kit”

Workflow steps

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

  1. Core Philosophy
  2. The Priority Stack
  3. Aesthetic Direction
  4. Typography Essentials
  5. Color & Theme
  6. Spatial Design
  7. Motion & Interaction
  8. Component Craft
  9. Accessibility Essentials
  10. Pre-Delivery Review

What it can do on your machine

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

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are css, typescript and html).

    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

Interface Kit loads about 5.3k tokens when it runs, and up to ~20k if it reads all its reference files. Until then it costs about 156 tokens; SKILL.md has 2,166 words of instructions outside code blocks.

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

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 passed

The automated check found no risky patterns in SKILL.md.

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); files beside SKILL.md are not scanned.

SKILL.md

The full file from JuliusBrussee/skills at commit 8470b26, republished under its MIT licence (© JuliusBrussee). 2,166 words, ~5,331 tokens.

Download SKILL.mdSave it as .claude/skills/interface-kit/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
interface-kit
description
Authoritative guide for implementing stunning, accessible, performant UI. Synthesizes design engineering philosophy, accessibility standards, animation principles, spatial design, typography, color systems, and component craft into a single actionable reference. Complements the design-system skill (which covers DESIGN.md spec writing) by covering the HOW of implementation. Trigger phrases: "build UI", "create component", "landing page", "make it look good", "frontend", "design", "polish UI", "implement design", "make it beautiful", "UI implementation", "component styling", "animation", "accessibility"

Interface Kit: Implementation Guide for Exceptional Interfaces

If a DESIGN.md exists at the project root, its tokens and specifications override all defaults in this skill. This skill provides sensible defaults for when no design system exists, and implementation guidance that applies regardless.

For deep dives on any section, see the reference files in this skill's references/ directory.


1. Core Philosophy

Taste is trained, not innate. Study why great interfaces feel right. Deconstruct apps you admire — the spacing, the timing, the weight of a shadow. The gap between "fine" and "exceptional" is built from hundreds of micro-decisions that users feel but never consciously notice.

Unseen details compound. A single rounded corner, a single eased transition, a single well-chosen shadow — none of these matter alone. Together they become "a thousand barely audible voices singing in tune." The cumulative effect is what separates craft from output.

Beauty is leverage. Polish is not vanity. Good defaults, considered typography, and intentional motion are real differentiators. Users trust interfaces that feel cared for. Investors notice. Competitors can't easily replicate taste.

Intentionality over intensity. Both bold maximalism and refined minimalism work — what fails is the absence of a clear point of view. Every visual decision should trace back to a deliberate conceptual direction. If you can't articulate WHY a choice was made, reconsider it.

Choose a direction and execute with precision. Don't hedge between styles. A brutalist page committed fully will always outperform a page that's "a little bit of everything." Commit, then refine.

NEVER produce generic "AI slop" aesthetics. No gratuitous gradients on white backgrounds. No cookie-cutter hero sections with stock illustrations. No safe, forgettable layouts that could belong to any product. Every interface should have a point of view that makes it recognizable.


2. The Priority Stack

When implementing UI, work through these priorities in order. Higher priorities are non-negotiable; lower priorities are polish that compounds quality.

PriorityLevelWhat It Means
AccessibilityCRITICALContrast 4.5:1, keyboard nav, ARIA semantics, visible focus rings. Ship nothing that excludes users.
PerformanceHIGHWebP/AVIF images, lazy loading below fold, CLS < 0.1, transform-only animations on the compositor thread.
TypographyHIGHFont smoothing, text-wrap balance/pretty, tabular-nums for data, 65ch max line length.
Layout & SpatialHIGH4/8px grid, concentric border radius, optical alignment over geometric.
Color & ThemeMEDIUMHSL custom properties, semantic tokens, dark mode pairs tested separately.
Motion & InteractionMEDIUMFrequency-based animation decisions, 150-300ms durations, ease-out default.
Polish & DetailsLOWLayered shadows over borders, press feedback on buttons, staggered enter animations.

Never skip a CRITICAL/HIGH item to chase a LOW item. A beautifully animated button that fails keyboard navigation is a net negative.


3. Aesthetic Direction

Before writing a single line of CSS, commit to a bold aesthetic direction. The most common failure mode in AI-generated UI is convergence on the same safe, forgettable look.

Pick a Tone

Choose one and commit fully:

  • Brutally minimal — generous whitespace, monospace type, stark contrast, near-zero decoration
  • Maximalist chaos — layered textures, clashing type scales, dense information, intentional visual noise
  • Retro-futuristic — CRT glow effects, monospace terminals, scan lines, neon on dark
  • Organic / natural — earth tones, rounded shapes, paper textures, hand-drawn accents
  • Luxury / refined — serif headlines, muted palettes, ample negative space, subtle gold or cream accents
  • Editorial / magazine — dramatic type hierarchy, full-bleed imagery, grid-breaking layouts
  • Playful / bold — bright primaries, chunky borders, exaggerated shadows, bouncy motion
Match Complexity to Vision

Maximalist design demands elaborate code — layered backgrounds, complex grid structures, multiple font stacks. Minimalist design demands surgical precision — every pixel of spacing matters more when there's nothing to hide behind.

The Ban List (When No DESIGN.md Exists)

When building without an existing design system, avoid these overused defaults that signal "AI-generated":

  • Fonts: Inter, Roboto, Arial, system-ui as display fonts, Space Grotesk
  • Colors: Purple-to-blue gradients on white backgrounds
  • Patterns: Generic hero with centered text + CTA + stock illustration

Vary between light and dark themes, different font pairings, different aesthetic directions. Never converge on the same choices across projects.

Visual Texture

Add depth through: gradient meshes, noise/grain overlays (filter: url(#noise)), layered transparencies, subtle background patterns, duotone image treatments.

DESIGN.md overrides this entire section. If DESIGN.md specifies Inter, use Inter. If it specifies purple gradients, use them. The ban list only applies when no design system exists and you're making aesthetic choices from scratch.


4. Typography Essentials

Typography is the single highest-leverage design element. Get it right and mediocre layouts still feel good. Get it wrong and nothing else saves it.

Root Setup
css
html {
  -webkit-font-smoothing: antialiased;
  -moz-osx-font-smoothing: grayscale;
  text-rendering: optimizeLegibility;
}

Apply font smoothing to the root layout. On macOS, the default sub-pixel rendering makes text appear heavier than the designer intended.

Text Wrapping
css
h1, h2, h3, h4, h5, h6 {
  text-wrap: balance;
}

p, li, dd, blockquote {
  text-wrap: pretty;
}

balance distributes heading lines evenly. pretty avoids orphaned words in body text.

Numeric Display
css
.data-value, .price, .counter, [data-numeric] {
  font-variant-numeric: tabular-nums;
}

Use tabular-nums for any number that updates dynamically — prices, counters, table columns. Without it, layout shifts as digit widths change.

Scale and Rhythm
  • Base size: 16px minimum for body text. Never go below 14px for any readable content.
  • Line height: 1.5-1.75 for body text, 1.1-1.3 for large headings.
  • Max line length: max-width: 65ch for body text. Long lines destroy readability.
  • Type scale: Pick a consistent scale and stick to it: 12 / 14 / 16 / 18 / 24 / 32 / 48 / 64.
Font Pairing

Pair a distinctive display font with a refined body font. The display font carries personality; the body font carries readability. Use font-weight for hierarchy within a family:

  • Headings: 600-700 (semibold to bold)
  • Body: 400 (regular)
  • Labels / UI: 500 (medium)

Always include font stack fallbacks:

css
--font-display: "Instrument Serif", "Georgia", serif;
--font-body: "Söhne", "Helvetica Neue", sans-serif;
--font-mono: "JetBrains Mono", "Fira Code", monospace;

5. Color & Theme

HSL Custom Properties (shadcn Pattern)
css
:root {
  --background: 0 0% 100%;
  --foreground: 222.2 84% 4.9%;
  --primary: 222.2 47.4% 11.2%;
  --primary-foreground: 210 40% 98%;
  --secondary: 210 40% 96.1%;
  --secondary-foreground: 222.2 47.4% 11.2%;
  --muted: 210 40% 96.1%;
  --muted-foreground: 215.4 16.3% 46.9%;
  --accent: 210 40% 96.1%;
  --accent-foreground: 222.2 47.4% 11.2%;
  --destructive: 0 84.2% 60.2%;
  --destructive-foreground: 210 40% 98%;
  --border: 214.3 31.8% 91.4%;
  --ring: 222.2 84% 4.9%;
  --radius: 0.5rem;
}

Define semantic tokens: primary, secondary, destructive, muted, accent, background, foreground. Reference colors by semantic name — never hardcode hex values in components.

Dark Mode
css
.dark {
  --background: 222.2 84% 4.9%;
  --foreground: 210 40% 98%;
  /* ... desaturated, lighter tonal variants — NOT simply inverted */
}

Dark mode is not "invert colors." Use desaturated, lighter tonal variants. Backgrounds go dark but not pure black (#000). Text goes light but not pure white (#fff). Test contrast separately for dark mode — what passes in light may fail in dark.

Contrast Requirements
  • WCAG AA minimum: 4.5:1 for normal text, 3:1 for large text (18px+ bold or 24px+ regular)
  • Never convey information by color alone — always pair with an icon, label, or pattern
  • Test with browser devtools contrast checker or axe-core
Color Confidence

Dominant colors with sharp accents outperform timid, evenly-distributed palettes. Pick one or two hero colors and let the rest of the palette recede. A confident palette has clear hierarchy; an uncertain palette spreads color evenly and feels flat.


6. Spatial Design

Concentric Border Radius

This is the single most common thing that makes nested UI elements feel "off":

outer_radius = inner_radius + padding
css
/* Correct: concentric */
.card        { border-radius: 16px; padding: 8px; }
.card-inner  { border-radius: 8px; }  /* 16 - 8 = 8 */

/* Wrong: same radius on parent and child */
.card        { border-radius: 12px; }
.card-inner  { border-radius: 12px; }  /* Looks bloated */

When geometric centering looks off, align optically. Play/pause icons, dropdown carets, and asymmetric glyphs often need 1-2px manual nudges to look centered.

Shadows Over Borders

Layer multiple transparent box-shadow values for natural depth instead of using borders:

css
.elevated {
  box-shadow:
    0 1px 2px rgba(0, 0, 0, 0.04),
    0 2px 4px rgba(0, 0, 0, 0.04),
    0 4px 8px rgba(0, 0, 0, 0.04);
}

Multiple shadows at different spreads mimic how light works. A single hard shadow looks artificial.

Image Outlines

Add a subtle inset outline to images and media for consistent depth against varied backgrounds:

css
img, video {
  outline: 1px solid rgba(0, 0, 0, 0.06);
  outline-offset: -1px;
}
Spacing Scale

Use a 4px / 8px base incremental system. Every spacing value should be a multiple of 4:

4 / 8 / 12 / 16 / 24 / 32 / 48 / 64 / 96 / 128

Hit Areas

Minimum 44x44px for all interactive elements. If the visual element is smaller, extend the hit area with a pseudo-element:

css
.small-button::before {
  content: "";
  position: absolute;
  inset: -8px;
}
Z-Index Scale

Define a layered scale and never use arbitrary values:

css
--z-base: 0;
--z-dropdown: 10;
--z-sticky: 20;
--z-overlay: 40;
--z-modal: 100;
--z-toast: 1000;

7. Motion & Interaction

The Frequency-Based Decision Framework

This is the most important mental model for animation decisions:

FrequencyExamplesAnimation
100+ times/dayKeyboard shortcuts, command palette actions, tab switchesNone. Zero animation. Instant.
Tens of times/dayHover effects, list item navigation, togglesRemove or drastically reduce. 50-100ms max.
OccasionalModals, drawers, toasts, page transitionsStandard animation. 150-300ms.
Rare / first-timeOnboarding, celebrations, empty statesCan add delight. 300-500ms, more elaborate.

High-frequency animations feel sluggish. Low-frequency animations without motion feel jarring. Match the animation budget to usage frequency.

Custom Easing Curves

Built-in CSS easings (ease, ease-in-out) are too weak. Define custom curves:

css
:root {
  --ease-out: cubic-bezier(0.23, 1, 0.32, 1);
  --ease-in-out: cubic-bezier(0.77, 0, 0.175, 1);
  --ease-drawer: cubic-bezier(0.32, 0.72, 0, 1);
  --ease-spring: cubic-bezier(0.34, 1.56, 0.64, 1);
}
Show full SKILL.md (872 more words)Show less
Duration Guide
ElementDuration
Buttons, toggles100-160ms
Tooltips125-200ms
Dropdowns, popovers150-250ms
Modals, drawers200-500ms
Page transitions250-400ms

UI animations should stay under 300ms. Never use ease-in for UI animations — it front-loads the pause and feels sluggish.

Enter/Exit Asymmetry

Exits should be softer and faster than enters. An enter animation at 250ms should have its exit at 150-200ms.

Split and Stagger Enter Animations

When multiple elements enter the viewport, stagger them by semantic chunks with ~50-100ms delay:

css
.stagger-item {
  animation: fadeSlideIn 300ms var(--ease-out) both;
}
.stagger-item:nth-child(1) { animation-delay: 0ms; }
.stagger-item:nth-child(2) { animation-delay: 60ms; }
.stagger-item:nth-child(3) { animation-delay: 120ms; }
Scale Animations

Never animate from scale(0). Start from scale(0.9) or higher, combined with opacity:

css
@keyframes scaleIn {
  from { opacity: 0; transform: scale(0.95); }
  to   { opacity: 1; transform: scale(1); }
}
Press Feedback

Every pressable element should scale down slightly on :active:

css
button:active {
  transform: scale(0.97);
}
Interruptibility

Use CSS transitions (not keyframe animations) for interactive state changes. Transitions can be interrupted mid-way; keyframes cannot. This matters for hover states, toggles, and any element the user might interact with rapidly.

Popover Origin

Make popovers transform-origin aware — they should grow from their trigger element, not from center. Exception: modals always originate from center.

Tooltip Hover Delay

Skip the tooltip delay on subsequent hovers. If the user has already waited for one tooltip, show the next one immediately.

Reduced Motion
css
@media (prefers-reduced-motion: reduce) {
  *, *::before, *::after {
    animation-duration: 0.01ms !important;
    transition-duration: 0.01ms !important;
  }
}

Respect prefers-reduced-motion. Reduce animations — don't eliminate opacity and color transitions entirely, as those provide important feedback.

Hover Gate

Gate hover animations behind a media query so touch devices don't trigger stuck hover states:

css
@media (hover: hover) and (pointer: fine) {
  .card:hover { transform: translateY(-2px); }
}

Reference references/animation-playbook.md for deep dives on spring physics, gesture-driven animation, and complex choreography.


8. Component Craft

Primitives

Use Radix UI primitives for accessible, unstyled foundations. Use CVA (class-variance-authority) for type-safe component variants:

tsx
import { cva } from "class-variance-authority";

const buttonVariants = cva(
  "inline-flex items-center justify-center rounded-md font-medium transition-colors focus-visible:outline-none focus-visible:ring-2",
  {
    variants: {
      variant: {
        default: "bg-primary text-primary-foreground hover:bg-primary/90",
        destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
        outline: "border border-input hover:bg-accent hover:text-accent-foreground",
        ghost: "hover:bg-accent hover:text-accent-foreground",
      },
      size: {
        sm: "h-9 px-3 text-sm",
        default: "h-10 px-4 py-2",
        lg: "h-11 px-8 text-lg",
      },
    },
    defaultVariants: { variant: "default", size: "default" },
  }
);
Button
  • Scale on press (transform: scale(0.97) on :active)
  • Visible focus ring (never outline: none without replacement)
  • Loading state with spinner replacing label, maintaining button dimensions
  • Disabled state at opacity: 0.5 with pointer-events: none
Card
  • Concentric border radius between card and inner elements
  • Layered shadows (not borders) for depth
  • Hover state: subtle elevation change (translateY(-1px) + shadow increase)
Dialog / Modal
  • Focus trap (keyboard cannot escape to elements behind)
  • ESC to close, click outside overlay to close
  • transform-origin: center, fade + scale enter animation
  • aria-modal="true", role="dialog", aria-labelledby
Form
  • Visible labels always — never placeholder-only inputs
  • Error messages near the field with aria-live="polite" for screen readers
  • Progressive disclosure: show advanced fields only when needed
  • Use React Hook Form + Zod for validation
Theming

Use shadcn CSS variable pattern (HSL format) for all component colors. Wrap client-interactive components in server components for Next.js App Router compatibility.

Reference references/component-patterns.md for the full component catalog with copy-paste implementations.


9. Accessibility Essentials

Semantic HTML First

Use <button>, <nav>, <main>, <header>, <footer>, <article>, <section> before reaching for ARIA. A <button> gives you keyboard handling, focus management, and screen reader semantics for free. A <div onClick> gives you none of that.

Keyboard Navigation
  • Tab / Shift+Tab: move between focusable elements
  • Enter / Space: activate buttons and links
  • Arrow keys: navigate within lists, menus, tabs, radio groups
  • Escape: close modals, popovers, dropdowns
  • Home / End: jump to first/last item in lists
Focus Management
  • Visible focus rings on all interactive elements — NEVER use outline: none without a replacement
  • Trap focus inside modals (Tab wraps within the modal, not behind it)
  • Restore focus to the trigger element when a modal/popover closes
  • Use focus-visible to show rings only for keyboard users, not mouse clicks:
css
:focus-visible {
  outline: 2px solid var(--ring);
  outline-offset: 2px;
}
ARIA Attributes
  • aria-label for icon-only buttons: <button aria-label="Close menu">X</button>
  • aria-labelledby to associate headings with sections
  • aria-describedby to link help text or error messages to inputs
  • aria-live="polite" for dynamic content updates (toast messages, form errors)
  • aria-hidden="true" for decorative elements (icons next to text labels)
  • aria-expanded for toggleable elements (dropdowns, accordions)
Color and Contrast
  • WCAG AA: 4.5:1 for normal text, 3:1 for large text
  • Never use color as the sole indicator — pair with icons, text, or patterns
  • Test in both light and dark modes
Images and Media
  • Descriptive alt text for meaningful images: alt="Dashboard showing 23% revenue growth"
  • Empty alt="" for purely decorative images
  • Captions for video, transcripts for audio
Navigation Aids
  • Skip link: first focusable element, hidden until focused:
html
<a href="#main-content" class="sr-only focus:not-sr-only">
  Skip to main content
</a>
  • Heading hierarchy: sequential h1 through h6, no level skips. One <h1> per page.
Touch Targets
  • Minimum 44x44px interactive area
  • 8px minimum spacing between adjacent touch targets
  • Extend small visual elements with invisible padding or pseudo-elements
Testing
  • Automated: axe-core in CI, Lighthouse accessibility score 90+
  • Manual: full keyboard-only navigation test
  • Screen reader: test with VoiceOver (macOS) or NVDA (Windows)
  • Visual: zoom to 200%, check nothing breaks or overlaps

Reference references/accessibility-checklist.md for the full audit guide with pass/fail criteria.


10. Pre-Delivery Review

Run through this checklist before considering any UI implementation complete:

Typography
  • Font smoothing applied (-webkit-font-smoothing: antialiased)
  • Headings use text-wrap: balance
  • Dynamic numbers use font-variant-numeric: tabular-nums
Color
  • All colors referenced via semantic tokens, no hardcoded hex in components
  • Color contrast meets WCAG AA (4.5:1 normal text, 3:1 large text)
  • Dark mode tested separately for contrast
Spatial
  • Nested rounded elements use concentric border radius
  • Spacing follows 4px / 8px scale consistently
  • Interactive elements have 44x44px minimum hit area
  • Shadows used instead of borders where appropriate
Motion
  • Animation frequency matches usage frequency (no animation on high-frequency actions)
  • No transition: all anywhere — specific properties only
  • Enter animations split and staggered where multiple elements appear
  • prefers-reduced-motion respected
Accessibility
  • All interactive elements keyboard accessible
  • Focus rings visible on keyboard navigation (never outline: none without replacement)
  • Semantic HTML used before ARIA
  • aria-live on dynamic content updates

Reference references/review-checklist.md for the extended 30-item checklist with severity ratings and automated testing commands.

© JuliusBrussee, 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 4 other files (references) in skills/interface-kit of JuliusBrussee/skills.

  • SKILL.md
  • references/accessibility-checklist.md
  • references/animation-playbook.md
  • references/component-patterns.md
  • references/review-checklist.md

Open the folder on GitHubat commit 8470b26

Used in 1 other repository

We found 1 copy of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in JuliusBrussee/skills, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Interface Kit 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.

Interface Kit compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Interface Kit this skillJuliusBrussee/skills1611 repos~5.3kAutomated safety check: PassMIT
Scalar Design Systemscalar/scalar16k—~2.7kAutomated safety check: PassMIT
UI/UX Design System AdvisorGalaxy-Dawn/claude-scholar5.7k1 repos~1.1kAutomated safety check: PassMIT
Frontend UI StandardsMaxHan7/frontend-ui-standards-skill106—~2.4kAutomated safety check: PassMIT
Replica DesignJakeschincariol/replica-skill908—~994Automated safety check: PassMIT
Design Theme Guidesickn33/agentic-awesome-skills47k1 repos~5.7kAutomated safety check: PassMIT

Similar skills

  • Scalar's design system — design tokens, theming (@scalar/themes), CSS variables, and the @scalar/components library.

    16k GitHub stars~2.7k tokensUpdated today
    Frontend & DesignAuto-check passed
  • UI/UX Design System Advisor

    Galaxy-Dawn/claude-scholar

    Turns a vague UI request into a concrete design system with style, palette, typography and layout guidance from a search script, plus stack-specific implementation advice.

    5.7k GitHub starsUsed in 1 repo~1.1k tokens
    Frontend & DesignAuto-check passed
  • Frontend UI Standards

    MaxHan7/frontend-ui-standards-skill

    A skill your agent uses when implementing, refactoring, or reviewing frontend UI across SwiftUI, React, React Native, Flutter, web, or mobile apps.

    106 GitHub stars~2.4k tokensUpdated 3 mo ago
    Frontend & DesignAuto-check passed
  • Replica Design

    Jakeschincariol/replica-skill

    Rebuilds an app's design system for a clone: colour roles, type scale, spacing, radius, shadows and every component with its states, as design tokens plus component specs, with original assets…

    908 GitHub stars~994 tokensUpdated 5 days ago
    Frontend & DesignAuto-check passed
  • Design Theme Guide

    sickn33/agentic-awesome-skills

    Design-token register: colour, typography, spacing and radius tokens with light and dark values, contrast ratio and WCAG level.

    47k GitHub starsUsed in 1 repo~5.7k tokens
    Frontend & DesignAuto-check passed
  • Omk Stitch

    KaimingWan/oh-my-kiro

    Google Stitch design-to-code workflow with design system management.

    107 GitHub stars~2.2k tokensUpdated 6 mo ago
    Frontend & DesignAuto-check passed

More from JuliusBrussee/skills

  • Context Canary

    JuliusBrussee/skills

    Install a per-turn canary signal (e.g. An agent skill from JuliusBrussee/skills.

    161 GitHub stars~1.6k tokensUpdated 2 mo ago
    Auto-check passed
  • Junior To Senior

    JuliusBrussee/skills

    Adversarial senior-engineer review for agent-generated plans, designs, and architectures.

    161 GitHub stars~2.3k tokensUpdated 2 mo ago
    Auto-check passed
  • Loop Factory

    JuliusBrussee/skills

    Run a spec-driven agent loop where coding tasks live as markdown specs that move through inbox → active → archive, get implemented by Claude Code or Codex, and pass a review gate before they count…

    161 GitHub stars~2k tokensUpdated 2 mo ago
    Auto-check passed
  • Grill Me

    JuliusBrussee/skills

    Calibrated grilling session for stress-testing a plan, design, idea, or decision.

    161 GitHub stars~1.6k tokensUpdated 2 mo ago
    Auto-check passed
  • Deslopify

    JuliusBrussee/skills

    De-slop pass for any text. An agent skill from JuliusBrussee/skills.

    161 GitHub stars~1.9k tokensUpdated 2 mo ago
    Auto-check passed

Questions about Interface Kit

What does Interface Kit do?

Authoritative guide for implementing stunning, accessible, performant UI. Interface Kit is an agent skill from JuliusBrussee/skills. Authoritative guide for implementing stunning, accessible, performant UI.

When should I use Interface Kit?

Interface Kit fits situations like: phrases: build UI; create component; make it look good; implement design.

How do I install Interface Kit in Claude Code?

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

How do I install Interface Kit in Codex?

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

Can I use Interface Kit 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 JuliusBrussee/skills --skill interface-kit -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/interface-kit, .gemini/skills/interface-kit, .github/skills/interface-kit and .opencode/skills/interface-kit in your project.

What does Interface Kit need to run?

SKILL.md names no scripts, command-line tools or credentials: Interface Kit is instructions for the agent only.

Does Interface Kit 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 Interface Kit safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Interface Kit use?

Interface Kit 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 Interface Kit use?

About 5.3k tokens (SKILL.md is roughly 21k 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 15k tokens, read only when the agent opens those files.

What are the alternatives to Interface Kit?

Skills that share tags, products or a category with Interface Kit: Scalar Design System (scalar/scalar, 16k stars), UI/UX Design System Advisor (Galaxy-Dawn/claude-scholar, 5.7k stars), Frontend UI Standards (MaxHan7/frontend-ui-standards-skill, 106 stars) and Replica Design (Jakeschincariol/replica-skill, 908 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Interface Kit?

JuliusBrussee (a GitHub user) maintains it in JuliusBrussee/skills, which has 161 GitHub stars. The repository holds 6 skills in this directory. The repository was last updated on August 7, 2026.

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