Micro Motion logo

Micro Motion

Organization
KyaniteLabs
micro-motion

Use when an interface needs purposeful feedback, transitions, or reduced-motion behavior, especially when animation risks jank, interruption bugs, or hidden no-JS content.

Overview

PublisherKyaniteLabs
Repositorytastecheck
Skill namemicro-motion
Stars
10
Forks
7
Bundled files
4
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 4 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by KyaniteLabs on GitHub. Read the source before you install it.

Installation

Install the Micro Motion AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/KyaniteLabs/tastecheck/tree/main/skills/micro-motion
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/KyaniteLabs/tastecheck.git /tmp/tastecheck
mkdir -p .claude/skills
cp -r /tmp/tastecheck/skills/micro-motion .claude/skills/micro-motion
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Micro Motion in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Micro Motion on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Micro Motion is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Micro-Motion

Motion confirms a change, origin, or what to notice next. If it answers none, cut it.

Non-negotiables (the rules that keep motion feeling good)

  • Prefer compositor-safe properties. Start with transform and opacity. Color, filter, SVG, or measured layout transitions need purpose and target-device trace.
  • Ease by direction. Ease-out enters, ease-in exits, ease-in-out moves; linear is for a purposeful continuous loop only.
  • Design reduced motion as an equivalent state. Keep labels, choices, focus, and content; remove spatial movement.
  • Let JavaScript opt elements into waiting states only after the observer is ready. Static CSS must not hide content when JavaScript fails, initializes late, or restores from the back-forward cache.
  • Make looping motion controllable and never scroll-jack.

Easing & duration tokens

Use semantic duration/easing tokens: acknowledgement 120–160ms, insertion/menu 160–220ms, confirmation/route 220–320ms. These are starting bands; test on target device. Motion never delays committed state, focus, or next keyboard action.

Settle before styling

Define usable end state and interruption policy before an entrance. Superseded save, route, insertion, or dismissal must converge on newest state without stale overlay, announcement, focus jump, or success message. Motion reflects ownership, not decides it. Unknown ownership/focus recovery goes to component-states.

The reduced-motion contract

Define the project-level reduced-motion policy once; components reference it. For progressive reveals, content starts visible. After the observer is attached, JavaScript marks only offscreen pending elements; never hide an already intersecting element. Remove the marker on reveal and page restoration. Gate spatial movement behind no-preference:

css
/* JavaScript marks only non-intersecting elements after the observer is ready. */
.reveal[data-reveal="pending"] { opacity: 0; }
.reveal:not([data-reveal="pending"]) { opacity: 1; }
@media (prefers-reduced-motion: no-preference) {
  .reveal[data-reveal="pending"] { transform: translateY(12px); }
  .reveal { transition: opacity var(--dur-base) var(--ease-out),
                        transform var(--dur-base) var(--ease-out); }
  .reveal:not([data-reveal="pending"]) { transform: none; }
}

For a legacy retrofit only, the emergency global kill switch in references/principles.md is permitted after documenting why the primary pattern cannot be used; it removes useful transitions and is not the default.

Decision order

  1. Name the user-facing purpose: acknowledgement, continuity, spatial origin, or attention.
  2. Name trigger, settled state, focus timing, and what wins when interrupted.
  3. Choose the smallest property, duration, and easing that communicate that purpose.
  4. Define reduced-motion and no-JS/restoration equivalents.
  5. Replay rapid repeat, cancellation, navigation, and stale async completion.

For async feedback, tag each request; only its current owner updates status/live announcement. For routes/overlays, cancel superseded animation and make destination DOM/focus authoritative. For list changes, preserve readable DOM order when movement is interrupted.

How to deliver

Deliver a choreography table: interaction, purpose, trigger, duration/easing, settled state, interruption rule, and reduced equivalent. Add one safety row for JS-disabled/restoration. Default to CSS; use a library only when gestures, springs, or layout coordination justify it.

Self-check

  • Properties are compositor-safe, or intentional alternative has a target-device trace
  • Durations/easings are tokens (--dur-*/--ease-*); entrances ~200–300ms ease-out (custom curve, not linear)
  • prefers-reduced-motion path tested (motion off or cross-fade) — content never depends on it
  • Page reads complete with JS disabled, delayed initialization, and bfcache restore; pending markers are added only to offscreen elements after observer ownership and cleared on pageshow
  • Rapid repeat, cancellation, stale completion, and navigation converge on the current usable state without stale focus, status, or layers
  • No scroll-jacking or uncontrolled loops; flashing stays below the safety threshold
  • Evidence names tokens, settled state, reduced equivalent, and replay result

Contract (generated)

Canonical detail: contract.json.

  • Route: An interface needs purposeful transition, feedback, choreography, or reduced-motion behavior.; avoid: The request is only static visual styling or decorative animation without an interaction purpose.
  • Exclude: Do not add motion without a user-facing purpose. (+2 in contract.json)
  • Stop / handoff: Stop when no purpose or interruption policy exists. (+1 in contract.json); receives [component-states, design-system-interview, deslop-ui, tasteroll] -> sends [a11y-pass, tastecheck-pass]
  • Output: purposeful motion choreography and token plan
  • Evidence: table_with_evidence with status, reason, remediation, evidence, provenance.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Micro Motion AI skill do?

Use when an interface needs purposeful feedback, transitions, or reduced-motion behavior, especially when animation risks jank, interruption bugs, or hidden no-JS content.

Why use Micro Motion on TypingMind?

Because you install it once and use it with any model. Micro Motion is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Micro Motion in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/KyaniteLabs/tastecheck/tree/main/skills/micro-motion. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Micro Motion?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Micro Motion?

As many as you like. As long as a model supports skills, you can use Micro Motion with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Micro Motion AI skill free?

Yes. It is published on GitHub by KyaniteLabs under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇