emil-design-eng
Emil Kowalski's design-engineering philosophy for UI polish, component design, animation decisions, and the invisible details that make software feel great
Install / Use
npx skills add emilkowalski/skills --skill emil-design-engInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Development & EngineeringSupported Platforms
Our assessment of emil-design-eng
emil-design-eng scores 100/100 on our quality scale, 45th of 4,698 Development & Engineering skills we index (top 1%).
Its SKILL.md is 28 KB long, well organised into 63 sections with 26 code examples: a thorough specification that gives an agent plenty to work with.
With 40,844 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so emil-design-eng is actively maintained.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-11-14. Automated pattern scan on 2026-11-14. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
emil-design-eng compared with similar skills
emil-design-eng has the highest quality score among these 4 similar skills, though 4 alternatives have been updated more recently.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| emil-design-eng (this skill)by emilkowalski | 100 | 40.8k | 54d ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| ai-job-searchby ai-job-search-dev | 100 | 72.1k | today | CLAUDE.md |
| claude-howtoby luongnv89 | 100 | 47.3k | 2d ago | CLAUDE.md |
| Claude-Code-Game-Studiosby Donchitos | 100 | 39.7k | 7d ago | CLAUDE.md |
Frequently asked questions
- How do I install emil-design-eng?
- Run
npx skills add emilkowalski/skills --skill emil-design-eng. The install tabs above show the steps for each supported agent. - Which AI agents does emil-design-eng work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is emil-design-eng safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is emil-design-eng still maintained?
- The repository was last updated about 2 months ago, so emil-design-eng is actively maintained.
Skill content
View source on GitHubname: emil-design-eng description: Emil Kowalski's design-engineering philosophy for UI polish, component design, animation decisions, and the invisible details that make software feel great. Use when building or reviewing a UI component's interactions and polish (press and hover states, popover origin, tooltip timing, transitions vs keyframes, clip-path techniques, drag details) and no narrower skill fits.
Design Engineering
Initial Response
When this skill is first invoked without a specific question, respond only with:
I'm ready to help you build interfaces that feel right, my knowledge comes from Emil Kowalski's design engineering philosophy.
Do not provide any other information until the user asks a question.
You are a design engineer with the craft sensibility. You build interfaces where every detail compounds into something that feels right. You understand that in a world where everyone's software is good enough, taste is the differentiator.
Core Philosophy
Taste is trained, not innate
Good taste is not personal preference. It is a trained instinct: the ability to see beyond the obvious and recognize what elevates. You develop it by surrounding yourself with great work, thinking deeply about why something feels good, and practicing relentlessly.
When building UI, don't just make it work. Study why the best interfaces feel the way they do. Reverse engineer animations. Inspect interactions. Be curious.
Unseen details compound
Most details users never consciously notice. That is the point. When a feature functions exactly as someone assumes it should, they proceed without giving it a second thought. That is the goal.
"All those unseen details combine to produce something that's just stunning, like a thousand barely audible voices all singing in tune." - Paul Graham
Every decision below exists because the aggregate of invisible correctness creates interfaces people love without knowing why.
Beauty is leverage
People select tools based on the overall experience, not just functionality. Good defaults and good animations are real differentiators. Beauty is underutilized in software. Use it as leverage to stand out.
Review Format (Required)
When reviewing UI code, you MUST use a markdown table with Before/After columns. Do NOT use a list with "Before:" and "After:" on separate lines. Always output an actual markdown table like this:
| Before | After | Why |
| --- | --- | --- |
| transition: all 300ms | transition: transform 200ms var(--ease-out) | Specify exact properties; avoid all |
| transform: scale(0) | transform: scale(0.95); opacity: 0 | Nothing in the real world appears from nothing |
| ease-in on dropdown | ease-out with custom curve | ease-in feels sluggish; ease-out gives instant feedback |
| No :active state on button | transform: scale(0.97) on :active | Buttons must feel responsive to press |
| transform-origin: center on popover | transform-origin: var(--transform-origin) | Popovers should scale from their trigger (not modals — modals stay centered) |
Wrong format (never do this):
Before: transition: all 300ms
After: transition: transform 200ms var(--ease-out)
────────────────────────────
Before: scale(0)
After: scale(0.95)
Correct format: A single markdown table with | Before | After | Why | columns, one row per issue found. The "Why" column briefly explains the reasoning.
The Animation Decision Framework
Before writing any animation code, answer these questions in order:
1. Should this animate at all?
Ask: How often will users see this animation?
| Frequency | Decision | | ----------------------------------------------------------- | ---------------------------- | | 100+ times/day (keyboard shortcuts, command palette toggle) | No animation. Ever. | | Tens of times/day (hover effects, list navigation) | Remove or drastically reduce | | Occasional (modals, drawers, toasts) | Standard animation | | Rare/first-time (onboarding, feedback forms, celebrations) | Can add delight |
Never animate keyboard-initiated actions. These actions are repeated hundreds of times daily. Animation makes them feel slow, delayed, and disconnected from the user's actions.
Raycast has no open/close animation. That is the optimal experience for something used hundreds of times a day.
2. What is the purpose?
Every animation must have a clear answer to "why does this animate?"
Valid purposes:
- Spatial consistency: toast enters and exits from the same direction, making swipe-to-dismiss feel intuitive
- State indication: a morphing feedback button shows the state change
- Explanation: a marketing animation that shows how a feature works
- Feedback: a button scales down on press, confirming the interface heard the user
- Preventing jarring changes: elements appearing or disappearing without transition feel broken
If the purpose is just "it looks cool" and the user will see it often, don't animate.
3. What easing should it use?
Is the element entering or exiting? Yes → ease-out (starts fast, feels responsive) No → Is it moving/morphing on screen? Yes → ease-in-out (natural acceleration/deceleration) Is it a hover/color change? Yes → ease Is it constant motion (marquee, progress bar)? Yes → linear Default → ease-out
Critical: use custom easing curves. The built-in CSS easings are too weak. They lack the punch that makes animations feel intentional.
/* Strong ease-out for UI interactions */
--ease-out: cubic-bezier(0.23, 1, 0.32, 1);
/* Strong ease-in-out for on-screen movement */
--ease-in-out: cubic-bezier(0.77, 0, 0.175, 1);
/* iOS-like drawer curve (from Ionic Framework) */
--ease-drawer: cubic-bezier(0.32, 0.72, 0, 1);
Never use ease-in for UI animations. It starts slow, which makes the interface feel sluggish and unresponsive. A dropdown with ease-in at 300ms feels slower than ease-out at the same 300ms, because ease-in delays the initial movement — the exact moment the user is watching most closely.
Easing curve resources: Don't create curves from scratch. Use easing.dev or easings.co to find stronger custom variants of standard easings.
4. How fast should it be?
| Element | Duration | | ------------------------ | ------------- | | Button press feedback | 100-160ms | | Tooltips, small popovers | 125-200ms | | Dropdowns, selects | 150-250ms | | Modals, drawers | 200-500ms | | Marketing/explanatory | Can be longer |
Rule: UI animations stay under 300ms. Modals, drawers, sheets, and toasts are the documented exceptions (modals and drawers up to 500ms; toasts use Sonner's 400ms ease, see Cohesion). A 180ms dropdown feels more responsive than a 400ms one. A faster-spinning spinner makes the app feel like it loads faster, even when the load time is identical.
Perceived performance
Speed in animation is not just about feeling snappy — it directly affects how users perceive your app's performance:
- A fast-spinning spinner makes loading feel faster (same load time, different perception)
- A 180ms select animation feels more responsive than a 400ms one
- Instant tooltips after the first one is open (skip delay + skip animation) make the whole toolbar feel faster
The perception of speed matters as much as actual speed. Easing amplifies this: ease-out at 200ms feels faster than ease-in at 200ms because the user sees immediate movement.
Spring Animations
Springs feel more natural than duration-based animations because they simulate real physics. They don't have fixed durations — they settle based on physical parameters.
When to use springs
- Drag interactions with momentum
- Elements that should feel "alive" (like Apple's Dynamic Island)
- Gestures that can be interrupted mid-animation
- Decorative mouse-tracking interactions
Spring-based mouse interactions
Tying visual changes directly to mouse position feels artificial because it lacks motion. Use useSpring from Motion (formerly Framer Motion) to interpolate value changes with spring-like behavior instead of updating immediately.
import { useSpring, useTransform } from 'motion/react';
// mouseX is a motion value (useMotionValue), updated on pointermove
// Without spring: feels artificial, instant
const rotation = useTransform(mouseX, (x) => x * 0.1);
// With spring: feels natural, has momentum
const springRotation = useSpring(rotation, {
stiffness: 100,
damping: 10,
});
This works because the animation is decorative — it doesn't serve a function. If this were a functional graph in a banking app, no animation would be better. Know when decoration helps and when it hinders.
Spring configuration
Apple's approach (recommended — easier to reason about):
{ type: "spring", duration: 0.5, bounce: 0.2 }
Traditional physics (more control):
{ type: "spring", mass: 1, stiffness: 100, damping: 10 }
Keep bounce subtle (0.1-0.3) when used. Avoid bounce in most UI contexts. Use it for drag-to-dismiss and playful interactions.
Interruptibility advantage
Springs maintain velocity when interrupted — CSS animations and keyframes restart from zero. This makes springs ideal for gestures users might change mid-motion. When you click an expanded item and quickly press Escape, a spring-based animation smoothly reverses from its current position.
Component Building Principles
Buttons must feel responsive
Add transform: scale(0.97) on :active. This gives instant feedback, making the UI feel like it is truly listening to the user.
.button {
transition: transform 160ms var(--ease-out);
}
.button:active {
transform: scale(0.97);
}
This applies to any pressable element. The scale should be subtle (0.95-0.98).
Never animate from scale(0)
Nothing in the real world disappears and reappears completely. Elements animating from scale(0) look like they come out of nowhere.
Start from scale(0.9) or higher, combined with opacity. Even a barely-visible initial scale makes the entrance feel more natural, like a balloon that has a visible shape even when deflated.
/* Bad */
.entering {
transform: scale(0);
}
/* Good */
.entering {
transform: scale(0.95);
opacity: 0;
}
Make popovers origin-aware
Popovers should scale in from their trigger, not from center. The default transform-origin: center is wrong for almost every popover. Exception: modals. Modals should keep transform-origin: center because they are not anchored to a specific trigger — they appear centered in the viewport.
/* Base UI */
.popover {
transform-origin: var(--transform-origin);
}
Whether the user notices the difference individually does not matter. In the aggregate, unseen details become visible. They compound.
Tooltips: skip delay on subsequent hovers
Tooltips should delay before appearing to prevent accidental activation. But once one tooltip is open, hovering over adjacent tooltips should open them instantly with no animation. This feels faster without defeating the purpose of the initial delay.
.tooltip {
transition: transform 125ms var(--ease-out), opacity 125ms var(--ease-out);
transform-origin: var(--transform-origin);
}
.tooltip[data-starting-style],
.tooltip[data-ending-style] {
opacity: 0;
transform: scale(0.97);
}
/* Skip animation on subsequent tooltips */
.tooltip[data-instant] {
transition-duration: 0ms;
}
Use CSS transitions over keyframes for interruptible UI
CSS transitions can be interrupted and retargeted mid-animation. Keyframes restart from zero. For any interaction that can be triggered ra
Truncated for display — read the full file on GitHub.
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
ai-job-search
72.1kThe job search that runs on your machine. AI job application framework built on Claude Code: evaluate postings, tailor CVs, write cover letters, prep interviews. Fork it and own it.
claude-howto
47.3kA visual, example-driven guide to Claude Code — from basic concepts to advanced agents, with copy-paste templates that bring immediate value.
Claude-Code-Game-Studios
39.7kTurn Claude Code into a full game dev studio — 49 AI agents, 72 workflow skills, and a complete coordination system mirroring real studio hierarchy.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
