做什么
Apple的界面设计和流体,物理运动的方法,为网络翻译
技能库 智客分类:设计创意 apple-design
苹果公司对界面设计和流体,物理运动的方法,为网络翻译. 在构建或审查手势驱动的UI,弹簧动画,拖放/擦出/平面交互,动力和中断的过渡,透明材料和深度,打字(光学缩放,跟踪,领先),减速运动,或苹果式界面后的设计地基(feedback,空间一致性,约束)时使用.
官方网址:skills.sh
先看中文介绍;官方 description 原文单独保留,不改写 SKILL.md。
Apple的界面设计和流体,物理运动的方法,为网络翻译
建立或审查手势驱动的UI、弹簧动画、拖动/摇动/平面互动、动能和可中断过渡、半透明材料和深度、打字(光学尺寸、跟踪、领先)、减动或设计基础(反馈、空间构成)
按 Agent Skills 渐进披露:启动时只加载 name 与 description(约 100 token);任务匹配后才读入整份 SKILL.md 正文;scripts/、references/、assets/ 仅在需要时再读。 本文件正文结构:Apple Design、Initial Response、The Core Idea、1. Response — kill latency、2. Direct manipulation — 1:1 tracking、3. Interruptibility — the single most important principle。
文件分析:这是一份仅含 SKILL.md 的指令型技能,代理激活后整份正文进入上下文。
Apple's approach to interface design and fluid, physical motion, translated for the web. Use when building or reviewing gesture-driven UI, spring animations, drag/swipe/sheet interactions, momentum and interruptible transitions, translucent materials and depth, typography (optical sizing, tracking, leading), reduced-motion, or the design foundations (feedback, spatial consistency, restraint) behind Apple-style interfaces.
Apple DesignInitial ResponseThe Core Idea1. Response — kill latency2. Direct manipulation — 1:1 tracking3. Interruptibility — the single most important principle4. Behavior over animation — use springs5. Velocity handoff — the seam between drag and animation6. Momentum projection — animate to where the gesture is *going*7. Spatial consistency — symmetric paths, anchored origins8. Hint in the direction of the gesture9. Rubber-banding — soft boundaries
来源分类:skills.sh agent-skill
nameapple-designdescription具体调用语法与可用工具以目标 Agent 客户端为准。 查看调用机制说明 ↗
先选择目标 Agent 和安装范围,保留技能包的附属文件,安装后检查客户端能否发现该技能。
复制安装指令给支持 Agent Skills 的代理,确认其中的目标目录与客户端匹配。
把 Agent Skill「apple-design」安装到我的项目:SKILL.md 原文与官方 description 见 https://zicq.com/zh/skills/skl-f6ddb53afa92c5d4-%E8%8B%B9%E6%9E%9C%E8%AE%BE%E8%AE%A1.html 请存为 .cursor/skills/apple-design/SKILL.md 或 .claude/skills/apple-design/SKILL.md,frontmatter 的 name 与 description 保持原样,不要改写。
需要 Node.js 与 npx。先查看仓库技能列表,确认实际名称。
npx skills add 'https://github.com/emilkowalski/skills' --list
npx skills add 'https://github.com/emilkowalski/skills' --skill 'apple-design'
CLI 会交互选择目标 Agent,默认安装到项目;用户级安装使用 -g。先通过查看命令核对仓库内容,再用 npx skills list 检查已安装技能。
When this skill is first invoked without a specific question, respond only with:
I'm ready to help you build fluid, Apple-style interfaces on the web, my knowledge comes from Apple's WWDC design talks, translated for the web.
Do not provide any other information until the user asks a question.
How Apple builds interfaces that stop feeling like a computer and start feeling like an extension of you. This knowledge comes from Apple's WWDC design talks — chiefly Designing Fluid Interfaces (WWDC 2018) — distilled and translated into the web platform (CSS, Pointer Events, requestAnimationFrame, spring libraries like Motion/Framer Motion).
The through-line: an interface feels alive when motion starts from the current on-screen value, inherits the user's velocity, projects momentum forward, and can be grabbed and reversed at any instant. Springs are the tool that makes all of this natural, because they are inherently interruptible and velocity-aware.
"When we align the interface to the way we think and move, something magical happens — it stops feeling like a computer and starts feeling like a seamless extension of us."
An interface is fluid when it behaves like the physical world: things respond instantly, move continuously, carry momentum, resist at boundaries, and can be redirected mid-motion. Everything below is a way to get closer to that.
Apple frames design as serving four human needs: safety/predictability, understanding, achievement, and joy. Every rule here serves one of them.
The moment lag appears, the feeling of directness "falls off a cliff." Response is the foundation everything else is built on.
click/touch-up to show feedback feels dead./* Feedback lives on the press, and it's instant */
.button:active {
transform: scale(0.97);
transition: transform 100ms ease-out;
}
"Touch and content should move together."
When the user drags something, it must stay glued to the finger — and respect the offset from where they grabbed it. Snapping to the element's center on grab breaks the illusion immediately.
setPointerCapture so tracking continues even when the pointer leaves the element's bounds.pointermove events), not just the current point — you'll need velocity at release.el.addEventListener('pointerdown', (e) => {
el.setPointerCapture(e.pointerId);
const grabOffset = e.clientY - el.getBoundingClientRect().top; // respect where they grabbed
// ...track position + timestamp history for velocity
});
"The thought and the gesture happen in parallel."
Every animation must be interruptible and redirectable at any moment. A user must be able to grab a moving element mid-flight and reverse it without waiting for the animation to finish. A closing modal the user grabs again should follow the finger — not finish closing first, then reopen.
@keyframes for anything gesture-driven — they can't be smoothly grabbed and reversed mid-flight. Springs animate from the current value by default, which is exactly what interruption needs."Think of animation as a conversation between you and the object, not something prescribed by the interface."
A pre-scripted, fixed-duration animation can't respond to new input. A spring can — new input just changes the target, and the motion stays continuous. Reach for springs for anything a user can touch.
Apple deliberately replaced the physics triplet (mass/stiffness/damping) with two designer-friendly parameters. Think in these:
1.0 = critically damped, no bounce, smooth settle. < 1.0 = overshoots and oscillates. Lower = bouncier.Defaults:
1.0 (critically damped) — graceful and non-distracting.0.8) only when the gesture itself carried momentum (a flick, a throw, a drag release). Overshoot on a menu that just faded in feels wrong; overshoot on a card you flicked feels right.Concrete values Apple ships:
| Interaction | Damping | Response |
| --- | --- | --- |
| Move / reposition (e.g. PiP) | 1.0 | 0.4 |
| Rotation | 0.8 | 0.4 |
| Drawer / sheet | 0.8 | 0.3 |
Web mapping (Motion / Framer Motion): the bounce + duration spring API maps closely to Apple's damping + response. A safe house style is damping: 1.0 springs everywhere by default; reserve bounce for momentum-driven, physical interactions.
import { animate } from 'motion';
// Critically damped default (no overshoot)
animate(el, { y: 0 }, { type: 'spring', bounce: 0, duration: 0.4 });
// Momentum interaction — a little bounce, only because a flick preceded it
animate(el, { y: target }, { type: 'spring', bounce: 0.2, duration: 0.4 });
When a gesture ends, the animation must continue at the finger's exact velocity, so there's no visible seam between dragging and animating. This is the detail that most separates "fluid" from "fine."
Pass the pointer's release velocity as the spring's initial velocity. Some spring APIs want relative velocity — normalize it by the remaining distance to the target:
relativeVelocity = gestureVelocity / (targetValue − currentValue)
Example: element at y=50, target y=150 (100px to go), finger moving 50px/s → initial spring velocity = 50 / 100 = 0.5. Framer Motion / Motion take absolute px/s velocity directly (velocity option), so you usually hand it the raw value.
"Take a small input and make a big output."
Don't snap to the nearest boundary from the release point. Use velocity to project the resting position — exactly like scroll deceleration — then snap to the target nearest that projected point. This is what makes a flick feel like it throws the element.
Apple's exact projection function (from the Designing Fluid Interfaces sample code):
// decelerationRate ≈ 0.998 for normal scroll feel; 0.99 for snappier
function project(initialVelocity /* px/s */, decelerationRate = 0.998) {
return (initialVelocity / 1000) * decelerationRate / (1 - decelerationRate);
}
const projectedEndpoint = currentPosition + project(releaseVelocity);
const target = nearestSnapPoint(projectedEndpoint); // choose target from the projection
animateSpringTo(target, { velocity: releaseVelocity }); // then hand off velocity (§5)
Note: the physics-textbook v²/(2·decel) is not what Apple ships — use the exponential-decay form above. This is the standard behavior in good bottom-sheets and carousels (Vaul, Embla).
"If something disappears one way, we expect it to emerge from where it came."
transform-origin to the trigger, so the spatial relationship between button and content is obvious. (This is the same origin-awareness point as popovers scaling from their trigger, not their center.)Humans predict a final state from a trajectory. Intermediate motion should telegraph where things are going — Control Center modules "grow up and out toward your finger." Make the in-between frames point at the outcome, not just interpolate blindly to it.
At an edge, resist progressively instead of stopping hard. A hard stop reads as "frozen"; continuous resistance reads as "responsive, but there's nothing more here." Apply damping that increases the further past the boundary the user drags.
// The further past the bound, the less the element follows — real things slow before they stop
function rubberband(overshoot, dimension, constant = 0.55) {
return (overshoot * dimension * constant) / (dimension + constant * Math.abs(overshoot));
}
swipeleft-type events) — they throw away the continuous tracking you need for feedback.Smoothness is about what's in the frames, not just the frame rate.
requestAnimationFrame is the web's display-synced clock (Apple uses CADisplayLink). Animate only compositor-friendly properties — transform and opacity — and hint with will-change where motion is imminent.Apple uses translucent materials as a floating functional layer that brings structure without stealing focus. On the web, approximate with backdrop-filter.
backdrop-filter: blur() + a semi-transparent background) with content scrolling underneath — not opaque bars that consume a fixed strip..toolbar {
background: rgba(255, 255, 255, 0.6);
backdrop-filter: blur(20px) saturate(180%);
border-top: 1px solid rgba(255, 255, 255, 0.4); /* bright top edge = light catching the material */
}
Three rules for combining senses (from Designing Audio-Haptic Experiences):
Reduced motion doesn't mean no feedback — it means a gentler, non-vestibular equivalent. Respond to three independent signals and bake them into your components:
prefers-reduced-motion: reduce — replace slides/springs/parallax with short opacity cross-fades or static transitions. Drop elastic/overshoot. Keep opacity/color changes that aid comprehension.prefers-reduced-transparency: reduce — make translucent surfaces frostier/solid: raise background opacity, drop the blur.prefers-contrast: more — near-solid backgrounds with a defined, contrasting border.Also: avoid full-viewport moving backgrounds, slow looping oscillations (near 0.2 Hz / one cycle per 5s), and abrupt brightness jumps (ease dark↔light theme changes). Make large moving objects semi-transparent while they travel, and fade big surfaces out during a large reposition and back in once settled.
@media (prefers-reduced-motion: reduce) {
.sheet { transition: opacity 200ms ease; transform: none !important; }
}
@media (prefers-reduced-transparency: reduce) {
.toolbar { background: white; backdrop-filter: none; }
}
Apple designs type to change shape with size; the same discipline applies on the web. (From The Details of UI Typography, WWDC 2020.)
letter-spacing is wrong somewhere. Tighten headings, leave body near 0.rem/em, not fixed px — so a larger font doesn't break the layout.:root { font: 100%/1.5 system-ui, sans-serif; } /* body: system font, comfortable leading */
.display {
font-size: clamp(2rem, 5vw, 4rem);
line-height: 1.05; /* tight leading for large text */
letter-spacing: -0.02em; /* negative tracking as it grows */
font-optical-sizing: auto;
}
The motion and craft above serve Apple's eight design principles (Principles of Great Design, WWDC 2026). Use these as the names you reason with:
Tactical rules that serve these:
| Need | Technique | Concrete value |
| --- | --- | --- |
| Default UI spring | Critically damped, no overshoot | damping 1.0, response 0.3–0.4 |
| Momentum / flick spring | Under-damped, slight bounce | damping ~0.8, response 0.3–0.4 |
| Gesture → spring velocity | Hand off release velocity | gestureVelocity / (target − current) if normalized |
| Flick landing point | Project momentum | current + (v/1000)·d/(1−d), d ≈ 0.998 |
| Interrupt cleanly | Start from presentation (live) value | read the on-screen transform |
| Avoid reversal "brick wall" | Carry velocity through re-target | spring that blends velocity |
| Reversible transition | Mirror the easing curve | inverse cubic-bézier |
| Decide reverse vs. commit | Use velocity sign, not position | at release |
| 1:1 drag | Pointer Events + capture | respect the grab offset |
| Feedback | On pointer-down, continuous | never only at the end |
| Boundary | Rubber-band, don't hard-stop | progressive resistance |
| Translucent chrome | backdrop-filter layer | content scrolls under |
| Type tracking | Size-specific, never fixed | tighten large text (-0.02em), body near 0 |
| Reduced motion | Cross-fade, not slide/spring | @media (prefers-reduced-motion) |
设计创意
设计和实施自动化工作流程,以节省时间和规模化操作作为独家. 用于识别重复任务实现自动化,构建跨工具的工作流程,设置触发器和行动,或优化现有自动化. 包括自动化机会识别,工作流程设计,工具选择(Zapier,Make,n8n),测试,和维护. 触发"自动","自动","工作流程自动…
设计创意
UI/UX设计智能及建筑抛光接口实施指导. 当用户要求UI设计,UX流量,信息架构,视觉风格方向,设计系统/托盘,组件规格,副本/显微镜,可访问性,或生成/critique/refine前端UI(HTML/CSS/JS,React,Next.js,Vue,Svelte,Tailw…
设计创意
创建美丽现代UI的专家前端设计指南. 在构建起落架页面,仪表板,或任何用户界面时使用.
设计创意
设计和输出 n8n 工作流程 JSON 有强力触发器, idempotency, 错误处理, 记录, 重试, 以及 人入"一站"审查队列. 当您需要可审计的自动化时使用.