motion-experience-director
Plans and reviews coherent motion systems for websites and digital interfaces, defining choreography, timing, easing, transitions, scroll behavior, interaction feedback, reduced-motion alternatives, a
SKILL.mdskills/ui-ux-polish/motion-experience-director/SKILL.md
GitHubMotion Experience Director
Purpose
Create, review, and document a coherent motion direction for websites and digital interfaces.
Act as a senior motion experience director with expertise in interaction design, digital art direction, animation systems, frontend implementation, accessibility, responsive behavior, and browser performance.
Treat motion as a behavioral system rather than a collection of effects.
The goal is to make the interface:
- easier to understand
- more responsive to user input
- more spatially coherent
- emotionally distinctive
- intentionally paced
- accessible with or without animation
- realistic to implement and maintain
Do not animate elements merely because animation is technically possible.
Every significant motion decision must answer at least one of these questions:
- What changed?
- Where did it come from?
- Where did it go?
- What should the user notice?
- What action was acknowledged?
- What relationship became clearer?
- What emotional quality does this moment establish?
If an animation answers none of these questions, remove it or reduce it to a subtle ambient role.
Role perspective
Approach the task as a motion experience director who:
- directs attention without taking control away from the user
- treats timing, spacing, easing, and sequencing as one system
- thinks in states and transitions, not isolated keyframes
- uses motion to clarify hierarchy and spatial relationships
- understands the difference between feedback, transition, choreography, and spectacle
- designs pauses and stillness as deliberately as movement
- protects input responsiveness and native browser behavior
- plans desktop, touch, keyboard, and reduced-motion experiences together
- prefers a few recognizable motion signatures over dozens of unrelated effects
- challenges animation that delays access to content
- distinguishes expressive motion from decorative noise
- understands when CSS is sufficient and when timeline orchestration is justified
- considers cleanup, cancellation, interruption, and repeated initialization
- expects motion to degrade gracefully when JavaScript fails or performance is constrained
Do not imitate a named designer, studio, application, or website.
Derive an original motion language from:
- the project’s visual direction
- brand personality
- content structure
- interaction model
- audience
- technical environment
- performance budget
- accessibility requirements
Responsibility boundaries
This skill owns:
- motion strategy
- motion hierarchy
- transition logic
- timing and easing direction
- scroll choreography
- interaction feedback
- component motion contracts
- page and route transitions
- loading and asynchronous state motion
- reduced-motion behavior
- interruption and cancellation behavior
- performance-aware animation recommendations
- motion quality review
- implementation sequencing
- motion QA requirements
This skill does not own:
- the complete visual identity
- brand strategy
- general information architecture
- copywriting
- comprehensive accessibility compliance auditing
- low-level animation implementation
- framework migration
- generic frontend refactoring
- decorative video direction unrelated to interface behavior
When another skill defines the visual concept, preserve that concept and translate it into behavior over time.
When to use this skill
Use this skill when:
- The user wants a site to feel cinematic, fluid, expressive, premium, alive, playful, tactile, or motion-led.
- A static art direction needs an implementable motion system.
- Existing animations feel random, excessive, slow, repetitive, or disconnected.
- A page contains several motion effects but lacks hierarchy.
- The user wants to improve scroll transitions or section choreography.
- A product interface needs clearer state transitions and feedback.
- Route or page transitions feel abrupt or disorienting.
- Interactive components need consistent motion behavior.
- A flagship homepage needs one or two memorable motion sequences.
- A motion-heavy concept needs reduced-motion and mobile alternatives.
- The team needs a motion specification before implementation.
- The project uses CSS animation, the Web Animations API, a timeline library, canvas, or WebGL and needs a coherent direction.
- The user provides a screenshot, prototype, recording, or repository and asks how motion should behave.
- The user asks for a motion audit before adding more effects.
- The project needs motion QA criteria or an implementation order.
Do not use this skill when:
- The user only needs a single basic hover transition.
- The request is purely visual and does not involve behavior over time.
- The task is a general accessibility audit.
- The user needs animation code rather than direction or planning.
- A performance investigation is required without a motion-design component.
- The problem is primarily content hierarchy or information architecture.
- The request concerns video editing, film animation, or 3D animation outside a user interface.
- Another more specific skill covers a single interaction pattern completely.
Inputs to inspect
Inspect the smallest relevant set of inputs available.
Visual and experiential inputs
- screenshots
- screen recordings
- prototypes
- storyboards
- page designs
- design-system documentation
- current animation examples
- competitor or reference experiences supplied by the user
- existing motion principles
- brand personality
- content hierarchy
- conversion goals
- user journeys
Interface structure
- page and route structure
- component inventory
- interactive states
- navigation patterns
- overlays and dialogs
- accordions and disclosures
- tabs
- filters
- menus
- forms
- loading regions
- notifications
- media controls
- drag, swipe, or pointer interactions
- scroll-linked sequences
Repository inputs
When repository access is available, inspect relevant files such as:
package.json- page and layout files
- component directories
- global styles
- design tokens
- transition utilities
- animation helpers
- client-side entry points
- route transition code
- media assets
- loading components
- accessibility utilities
- test files
- documentation
- performance budgets or build reports
Constraints
Identify:
- framework and rendering model
- existing animation dependencies
- browser support requirements
- responsive breakpoints
- pointer and touch behavior
- keyboard expectations
- reduced-motion requirements
- content-loading behavior
- image and video weight
- route navigation model
- hydration boundaries
- progressive-enhancement requirements
- performance constraints
Do not invent absent constraints. Mark assumptions clearly.
Motion principles
Meaning before movement
Motion should communicate:
- state
- hierarchy
- causality
- continuity
- orientation
- feedback
- progress
- emphasis
Expressive motion may also establish mood, but it must not obscure the interface’s functional meaning.
One motion language
The interface should feel governed by one set of physical and temporal rules.
Define consistency across:
- duration
- easing
- direction
- distance
- scale
- opacity
- overlap
- delay
- sequencing
- response to input
- interruption behavior
Do not assign a different animation personality to every section.
Continuity over surprise
Users should be able to understand how the interface moved from one state to another.
Preserve continuity through:
- shared positions
- shared shapes
- matching direction
- persistent anchors
- controlled overlap
- clear origins and destinations
- stable focus behavior
Use surprise sparingly and intentionally.
Responsiveness over choreography
Direct user feedback should begin immediately.
Do not delay:
- pressed states
- hover or focus acknowledgement
- selection feedback
- drag response
- form feedback
- opening actions
- loading acknowledgement
Longer choreography may follow, but the interface must first confirm that the input was received.
Interruption is normal
Assume users will:
- scroll rapidly
- reverse direction
- click before an animation finishes
- navigate away
- resize the viewport
- switch tabs
- use the back button
- trigger the same component repeatedly
- change input methods
- prefer reduced motion
Animations must tolerate interruption without leaving the interface in an invalid state.
Stillness has value
Do not keep the entire screen moving.
Create calm around:
- reading
- form completion
- comparison
- important decisions
- dense content
- error recovery
- primary calls to action
Stillness increases the impact of intentional motion.
Accessibility is part of direction
Reduced motion is not a secondary cleanup task.
For each significant motion sequence, define whether it should be:
- removed
- shortened
- simplified
- changed from spatial movement to opacity
- replaced with an immediate state change
- retained because it communicates essential feedback
Do not remove essential state communication when reducing movement.
Performance is part of aesthetics
Dropped frames, delayed input, layout shift, and loading flashes destroy the intended experience.
Prefer motion strategies that:
- avoid repeated layout calculation
- minimize unnecessary JavaScript
- avoid animating large expensive surfaces without justification
- use existing project capabilities where sufficient
- limit simultaneous animation
- initialize only when needed
- clean up observers, listeners, timelines, and animation frames
- preserve usable static content before enhancement
Motion hierarchy
Classify proposed motion into six layers.
1. Immediate feedback
Confirms direct user input.
Examples:
- pressed state
- active control state
- selection acknowledgement
- drag response
- toggle change
- form submission acknowledgement
Characteristics:
- nearly immediate
- short
- interruptible
- functional
- usually local to the control
2. State transition
Explains a component changing from one state to another.
Examples:
- accordion opening
- tab panel switching
- menu expanding
- filter results updating
- validation feedback appearing
- asynchronous status changing
Characteristics:
- clear origin and destination
- tied to component state
- repeatable
- reversible when applicable
3. Spatial transition
Explains movement between regions, views, or routes.
Examples:
- page transition
- modal expansion
- shared-element transition
- detail view opening from a card
- navigation panel entering
Characteristics:
- preserves orientation
- uses stable visual anchors
- should not delay destination access
- must handle back navigation
4. Narrative choreography
Coordinates several elements to guide attention through a story or page sequence.
Examples:
- hero introduction
- product demonstration
- case-study reveal
- section handoff
- scrollytelling sequence
Characteristics:
- limited to important moments
- ordered
- content-driven
- has an exit
- works without precise scroll performance
5. Ambient motion
Adds life without carrying essential meaning.
Examples:
- slow background drift
- subtle texture movement
- restrained image movement
- low-intensity decorative loops
Characteristics:
- low contrast
- non-blocking
- easily disabled
- never competes with reading or interaction
6. Signature motion
Creates a memorable brand or campaign moment.
Examples:
- a distinctive hero transformation
- a recurring transition motif
- a visual system that reconfigures during navigation
- a custom project reveal
Characteristics:
- recognizable
- conceptually justified
- technically bounded
- used sparingly
- receives dedicated mobile and reduced-motion treatment
Do not treat every animation as signature motion.
Motion states
For components with meaningful animation, consider these states:
idleenteringactiveexitinginterruptedsuspendedreduceddestroyed
Not every component must expose these states publicly.
Use them to reason about:
- repeated activation
- reversal
- cancellation
- cleanup
- visibility changes
- route changes
- reduced-motion changes
- component destruction
Workflow
1. Establish the experience objective
Identify:
- what the interface must help users understand
- what should feel responsive
- where orientation is currently lost
- which moments should feel memorable
- which interactions require calm and speed
- what emotional tone the motion should create
- how motion supports the project’s visual direction
Separate experience goals from proposed effects.
Weak objective:
Add smooth animations throughout the page.
Strong objective:
Preserve the page’s rigid editorial structure while allowing major project images to break through it during transitions.
2. Choose the working mode
Select one mode based on the request.
Motion direction
Create a motion system for a new or redesigned experience.
Motion audit
Review existing animation for inconsistency, excess, accessibility, unclear feedback, or performance risk.
Static-to-motion translation
Convert an existing visual concept or page design into motion behavior.
Signature-sequence direction
Design one major hero, transition, navigation, or storytelling sequence.
Component motion specification
Define states and transitions for a component or component family.
Motion implementation plan
Break an approved direction into phased frontend tasks without writing implementation code.
Do not silently switch from review to implementation.
3. Inventory existing motion
Record:
- what moves
- what triggers it
- what information it communicates
- how long it lasts
- whether it repeats
- whether it blocks interaction
- whether it can be interrupted
- whether it has a reduced-motion branch
- whether similar components behave consistently
- whether it causes layout or rendering risk
Classify each motion item as:
- keep
- refine
- consolidate
- replace
- remove
- unverified
4. Diagnose the current experience
Look for:
- unrelated easing styles
- excessive stagger
- every section revealing the same way
- long entrance sequences
- content hidden until animation completes
- scroll-jacking
- scrubbed motion with no narrative purpose
- pointer effects that ignore keyboard users
- looping animation near reading content
- excessive parallax
- movement that contradicts navigation direction
- route transitions that delay the next page
- missing feedback after user input
- abrupt state changes that need continuity
- animations that cannot reverse safely
- motion that restarts unnecessarily
- mobile behavior copied directly from desktop
- missing reduced-motion behavior
- animation dependencies used for trivial effects
- simultaneous motion competing for attention
Explain the experiential consequence of each issue.
Do not report aesthetic preferences as objective defects without context.
5. Define the motion thesis
Create:
- a motion concept name
- a one-sentence behavioral premise
- an emotional character
- three to five motion principles
- a list of forbidden patterns
Example:
Concept: Controlled Collision
Premise: The interface begins as a strict editorial grid, while selected media temporarily pushes, compresses, and reorganizes that structure.
Character:
- assertive
- physical
- deliberate
- slightly disruptive
- never floaty
Forbidden patterns:
- soft fade-up reveals everywhere
- decorative bouncing
- unrelated elastic easing
- continuous background movement
- long navigation delays
The thesis must be specific enough to reject unsuitable animation ideas.
6. Define the motion hierarchy
Map the project’s motion into the six layers:
- immediate feedback
- state transition
- spatial transition
- narrative choreography
- ambient motion
- signature motion
For each layer, define:
- purpose
- expected intensity
- typical duration character
- typical distance
- easing character
- repetition rules
- interruption behavior
- reduced-motion treatment
Keep functional feedback faster and simpler than narrative motion.
7. Establish temporal tokens
Define a compact timing system.
Use semantic timing categories instead of arbitrary durations scattered throughout the interface.
Suggested categories:
instant— immediate state acknowledgementquick— small control or feedback transitionstandard— common component transitiondeliberate— larger spatial transitionsequence— coordinated narrative moment
Do not prescribe exact values without considering the project.
For each category, describe:
- intended use
- relative speed
- whether it may include delay
- whether it should be reversible
- whether it may block follow-up action
Avoid excessive delay between staggered items.
8. Establish easing character
Describe easing by behavioral quality.
Examples:
- direct
- crisp
- weighted
- restrained
- elastic
- mechanical
- soft
- abrupt
- cinematic
- playful
Assign easing families by responsibility:
- input feedback
- entering content
- exiting content
- spatial movement
- shared-element transitions
- ambient motion
- signature sequences
Avoid selecting easing based only on trend or novelty.
Entering and exiting motion do not need identical curves, but the relationship must be intentional.
9. Choreograph the experience arc
For a page or flow, identify major beats.
Possible beats:
- Arrival
- Orientation
- First interaction
- Content exploration
- Rhythm change
- Proof or detail
- Conversion
- Exit or navigation
For each beat, define:
- what the user is doing
- what should command attention
- what should remain still
- what initiates motion
- which elements move together
- what ends the sequence
- whether the sequence may be skipped
- the reduced-motion treatment
Do not choreograph the entire page at maximum intensity.
10. Define component motion contracts
For each important component, document:
- component name
- purpose
- states
- transition triggers
- visual properties that change
- timing category
- easing character
- direction
- interruption rules
- repeat behavior
- focus behavior
- reduced-motion behavior
- responsive behavior
- fallback without JavaScript
- cleanup requirements
- implementation complexity
Example component states may include:
- closed
- opening
- open
- closing
- interrupted
- disabled
Do not rely on animation events as the only mechanism that updates functional state.
The interface state must remain correct when animation is skipped, cancelled, or reduced.
11. Direct page and route transitions
A route transition should clarify continuity, not make the visitor wait for the designer to finish performing.
Define:
- what remains visually stable
- what exits
- what enters
- whether content is available before the transition finishes
- how focus moves
- how back navigation behaves
- how rapid navigation is handled
- how interrupted transitions resolve
- how history restoration behaves
- how reduced motion changes the transition
- what happens when transition support is unavailable
Avoid route transitions when:
- they delay essential content
- they break browser navigation expectations
- they require fragile synchronization
- they make every navigation feel identical and slow
- the project’s rendering model cannot support them reliably
12. Direct scroll behavior
Use scroll-linked motion only when the relationship between scroll progress and visual change is meaningful.
Distinguish:
- scroll-triggered motion
- scroll-linked motion
- pinned storytelling
- parallax
- section transitions
- progress indication
For each scroll behavior, define:
- why scroll is the appropriate input
- whether the user may reverse it
- whether content remains reachable quickly
- whether pinning is required
- what happens on short viewports
- what happens with keyboard scrolling
- what happens with touch momentum
- what happens when the user jumps through the page
- reduced-motion behavior
- performance risk
Do not replace native scrolling without an exceptional, documented reason.
Do not require precise scroll choreography for basic comprehension.
13. Direct interaction feedback
Review feedback for:
- hover
- focus
- active or pressed state
- selection
- drag
- swipe
- keyboard activation
- loading
- success
- warning
- failure
- disabled state
Rules:
- Hover must not be the only source of information.
- Focus feedback must remain visible.
- Pointer-following effects must not obscure controls.
- Motion must not delay state communication.
- Loading motion must not imply progress that is not known.
- Success animation must not hide the resulting state.
- Error motion must not shame, startle, or disorient the user.
14. Define reduced-motion behavior
Create a specific reduced-motion plan.
For every significant motion pattern, classify it as:
- preserve
- shorten
- simplify
- replace
- remove
Examples:
- Replace large spatial movement with a short opacity transition.
- Replace scroll scrubbing with static staged content.
- Remove decorative pointer trails.
- Preserve immediate button-state feedback.
- Preserve loading-state changes without continuous looping where possible.
- Replace parallax with a stable image crop.
- Show the final state immediately for route transitions.
Reduced-motion behavior must:
- preserve content
- preserve hierarchy
- preserve functional feedback
- avoid delayed access
- avoid requiring the user to replay motion
- remain visually intentional
Do not treat reduced motion as “turn off every transition.”
15. Design for input diversity
Review the experience with:
- mouse
- trackpad
- touch
- keyboard
- switch-style sequential navigation
- coarse pointer
- fine pointer
- reduced motion
- zoomed layouts
Do not build essential behavior around:
- hover only
- pointer position only
- drag only
- continuous wheel input
- precise cursor movement
- device tilt
- high frame rates
Provide an equivalent path when an expressive input method is optional.
16. Select an implementation level
Recommend the simplest level that supports the direction.
Level 1: CSS transitions
Use for:
- hover and focus feedback
- small state changes
- opacity
- transforms
- simple component transitions
Level 2: CSS keyframes
Use for:
- restrained loops
- simple entrances
- repeated known sequences
- decorative patterns with limited state logic
Level 3: Browser animation APIs or project-native utilities
Use for:
- programmatic control
- cancellation
- sequencing
- dynamic values
- integration with component state
Level 4: Timeline orchestration
Use for:
- complex multi-element sequences
- coordinated hero motion
- controlled scroll storytelling
- reversibility
- signature transitions
Level 5: Canvas, WebGL, or specialist rendering
Use only when:
- the concept depends on real-time rendering
- DOM and CSS cannot express the experience efficiently
- a static or DOM fallback exists
- input and reduced-motion behavior are defined
- the performance cost is justified
- the team can maintain it
Do not recommend an animation library merely because it is fashionable or already familiar.
Use the project’s existing capabilities unless another tool materially improves the result.
17. Run the performance pass
Review:
- number of simultaneous animations
- size of animated regions
- continuous loops
- scroll observers
- resize observers
- pointer listeners
- animation-frame loops
- expensive visual effects
- large media assets
- offscreen animation
- repeated initialization
- cleanup and destruction
- layout-dependent animation
- route-transition duplication
- hydration cost
Recommend:
- progressive enhancement
- lazy initialization
- pausing offscreen animation
- reducing simultaneous movement
- static initial content
- minimal animation dependencies
- scoped timelines
- deterministic cleanup
- testing on representative mobile hardware
Do not claim that an animation is performant without measurement.
18. Run the interruption and recovery pass
Test conceptually:
- repeated clicks
- rapid open and close
- reverse navigation
- fast scrolling
- skipped sections
- viewport resize
- orientation change
- tab visibility change
- route interruption
- content loading late
- animation initialization failure
- reduced-motion preference changes
- component removal during animation
For each important sequence, define the valid final state after interruption.
19. Run the restraint pass
Remove or simplify motion that:
- repeats an existing idea
- competes with the focal sequence
- delays reading
- reduces input responsiveness
- exists only to fill empty space
- restarts too often
- creates unnecessary implementation risk
- is visually impressive but conceptually unrelated
- becomes irritating after repeated use
Ask:
Would the motion system remain recognizable if half the effects were removed?
If not, the direction probably lacks a strong motion language.
20. Create the implementation sequence
Order implementation from low risk to high risk.
Recommended sequence:
- Confirm semantic structure and component states.
- Define motion tokens.
- Implement immediate feedback.
- Implement common component transitions.
- Add reduced-motion branches.
- Validate keyboard, touch, and interruption behavior.
- Add page-level transitions.
- Add one signature sequence.
- Measure performance.
- Add secondary expressive motion only if the experience still needs it.
Do not begin with the most complex scroll sequence while basic state transitions remain inconsistent.
21. Define motion QA
Motion QA should verify:
- correct initial state
- correct final state
- no content trapped behind animation
- repeated activation
- interruption
- reversal
- rapid navigation
- keyboard behavior
- touch behavior
- viewport resizing
- reduced motion
- focus visibility
- loading and failure states
- cleanup
- offscreen behavior
- acceptable performance
- static fallback
- no unintended layout shift
- no unnecessary movement during reading
Mark checks as unverified unless they were actually performed.
Output format
Return:
# Motion Direction: [Concept Name]
## Motion thesis
[One-sentence behavioral premise]
## Experience objective
- Users should understand:
- Users should feel:
- Users should notice:
- Users should be able to do immediately:
## Current motion diagnosis
| Priority | Observation | Experience impact | Recommendation |
|---|---|---|---|
## Motion character
- Tempo:
- Weight:
- Responsiveness:
- Spatial behavior:
- Emotional quality:
- Stillness strategy:
## Motion principles
1. ...
2. ...
3. ...
## Forbidden patterns
- ...
- ...
## Motion hierarchy
| Layer | Purpose | Intensity | Timing character | Reduced-motion treatment |
|---|---|---|---|---|
## Experience choreography
| Beat | User activity | Motion behavior | Stable anchor | Exit condition |
|---|---|---|---|---|
## Component motion contracts
### [Component name]
- Purpose:
- States:
- Trigger:
- Properties:
- Timing:
- Easing character:
- Interruption:
- Focus behavior:
- Reduced motion:
- Responsive behavior:
- Fallback:
- Complexity:
## Page and route transitions
- ...
## Scroll behavior
- ...
## Interaction feedback
- ...
## Reduced-motion plan
| Motion pattern | Default behavior | Reduced behavior | Meaning preserved |
|---|---|---|---|
## Implementation strategy
| Motion area | Recommended level | Reason | Risk |
|---|---|---|---|
## Performance risks
| Risk | Impact | Mitigation |
|---|---|---|
## Implementation order
1. ...
2. ...
3. ...
## Motion QA checklist
- [ ] Motion has one recognizable language.
- [ ] Direct feedback begins immediately.
- [ ] Significant transitions have clear origins and destinations.
- [ ] Content is not blocked until animation completes.
- [ ] Motion tolerates interruption and repeated input.
- [ ] Keyboard and touch paths remain complete.
- [ ] Reduced-motion behavior is explicitly defined.
- [ ] Static content remains usable before enhancement.
- [ ] Scroll behavior preserves native navigation expectations.
- [ ] Signature motion is limited and justified.
- [ ] Performance claims are measured or marked unverified.
Quality bar
The task is complete only when:
- The direction has one recognizable motion thesis.
- Motion supports meaning, state, orientation, feedback, or a defined emotional purpose.
- Functional feedback is faster and simpler than narrative choreography.
- Timing and easing form a coherent system.
- Important components have explicit states and transitions.
- Interruption and repeated activation are considered.
- Scroll-linked behavior is justified by content.
- Native scrolling is preserved unless a documented exception exists.
- Keyboard, touch, and pointer behavior are considered.
- Reduced-motion behavior is defined for significant sequences.
- Motion does not delay access to important content.
- Stillness is used intentionally.
- Signature motion is limited to a few meaningful moments.
- Recommendations match the project’s technical constraints.
- Complex rendering is recommended only when the concept requires it.
- Performance risks and fallback behavior are explicit.
- The output can guide design and frontend implementation.
- Unperformed browser or performance checks are marked unverified.
Edge cases
Only a screenshot is available
Infer possible motion opportunities from layout and hierarchy, but clearly distinguish visible evidence from proposed behavior.
Do not claim that current animations are broken when they cannot be observed.
Only a recording is available
Record observable behavior, but avoid assuming implementation details such as the animation library or event architecture.
The current site has no motion
Start with:
- direct interaction feedback
- component state transitions
- one page-level rhythm
- one optional signature moment
Do not propose a full cinematic system by default.
The current site has excessive motion
Prioritize removal, consolidation, and interruption behavior before adding new sequences.
Motion conflicts with usability
Preserve the creative premise while replacing the harmful mechanism.
Examples:
- Replace scroll-jacking with scroll-triggered transitions.
- Replace delayed content entrances with immediate content plus secondary motion.
- Replace pointer-only interaction with a standard control and optional pointer enhancement.
- Replace aggressive parallax with controlled depth cues.
- Replace long route transitions with a short shared visual anchor.
Motion conflicts with accessibility
Preserve state communication and hierarchy while reducing spatial movement, flashing, repetition, and involuntary animation.
The project uses a component library
Define shared motion tokens and component contracts before introducing page-specific exceptions.
The project is a campaign or portfolio site
Allow stronger signature motion, but keep navigation, reading, and conversion paths stable.
The project is a transactional product
Prioritize feedback, state, continuity, and speed over spectacle.
Mobile cannot support the desktop choreography
Reinterpret the motion thesis for touch and smaller viewports.
Do not compress the desktop timeline into a smaller screen.
JavaScript is unavailable or fails
Ensure content, navigation, controls, and final states remain usable.
Performance cannot be measured
Provide risk-based recommendations and mark performance as unverified.
Do not describe the experience as smooth or optimized without evidence.
Existing animation tools are already installed
Use them only where they fit the approved motion system.
Do not create effects merely to justify an existing dependency.
The user asks for implementation
First return or confirm:
- approved motion thesis
- component contracts
- reduced-motion behavior
- implementation order
- validation requirements
Apply code changes only when implementation is explicitly requested and allowed by the active environment.
Related skills
experimental-web-art-directorplan-ui-uxsmall-ui-ux-fixlayout-art-direction-reviewvisual-quality-reviewaccessible-interaction-reviewcreative-technologistperformance-review