Designers
One motion workflow: from a website to Figma to Claude to code
A motion workflow for teams: capture a website animation, save it in My Gallery, refine it in Figma, rebuild it with Claude and hand it off. With a checklist.
Motion tends to get lost between people. A designer finds an animation they like on a website, records it, and rebuilds it by eye in Figma. A developer gets a video and a note, guesses the numbers, and builds something close. By the time it ships, nobody can say where the timing came from.
This post sets out one workflow that keeps the same numbers from the first capture to the final code. It uses the Capture Motion extension, My Gallery, the Capture Motion Figma plugin and Claude (ChatGPT works the same way). It is written for small product teams where a designer and a developer share the work.
The five stages
- Capture the animation from the website with the Chrome extension.
- Save the capture JSON in My Gallery so it has a home.
- Refine it in Figma as an editable timeline.
- Rebuild it in code with Claude, using the captured timings.
- Hand off one set of values that design and code agree on.
The thread through all five is the capture JSON. Everything else is built from it.
Stage 1: capture
Open the page in Chrome, click the Capture Motion icon, then click the smallest container that holds the whole motion. Trigger the animation the way a visitor would: reload, scroll, click or hover. The extension records CSS transitions and keyframes, the Web Animations API, GSAP and Lottie.
Check the preview before you go further. It replays the capture and shows each animated property with its keyframes, durations, delays and easing. If something is missing, capture again with a larger container. A few minutes here saves an hour of confusion later. The Chrome extension guide covers picking and triggering in detail.
When it looks right, click the Capture Motion button. It copies the capture to the clipboard as JSON. This step needs a free account.
Stage 2: save it in My Gallery
A capture that only lives in a clipboard or a chat thread will be lost by next week. Give it a home.
- Open My Gallery and click + Add capture. You sign in first.
- Choose Paste JSON and paste the capture.
- Name it clearly. The name is optional, but a name such as "Pricing card lift, source site, desktop" is far easier to find than a default.
- Click Save capture.
If you recapture later, for example at a different window size, use replace its JSON on the same item rather than adding a near-duplicate. Your plan sets how many captures you can keep. Saving animations to My Gallery covers the library in full.
Stage 3: refine in Figma
Open the Capture Motion plugin in your Figma file and paste the JSON. The plugin rebuilds the capture as a Figma Motion timeline in Figma Design, with layers, keyframes, durations, delays and easing, ready to edit.
This is where the designer turns someone else's motion into your product's motion:
- Swap in your own layers: your components, type, images and colours.
- Tune the timing for your context. A marketing page can run slower than a settings screen.
- Trim tracks you do not need. Websites often animate more than they have to.
- Decide the reduced-motion version, usually a short fade with no movement.
Then write down every value you changed. The plugin's job is to turn JSON into a timeline, so the changes made in Figma need to travel to code as written values. A short table next to the frame is enough. The Figma plugin guide has more on editing the timeline.
Stage 4: rebuild with Claude
The developer now builds it. The quickest route is a language model, given the captured data rather than a description.
- Get the prompt. In the extension, Copy for LLM copies the capture JSON with a ready-made instruction for ChatGPT or Claude. If you are starting from a gallery card instead, use Copy > LLM prompt.
- Add the stack. Ask for React or Tailwind if that is what you use.
- Add the Figma changes. Paste in the values the designer wrote down, and say which tracks were removed.
- Ask it to keep every other timing as given. This stops the model from "improving" numbers you chose on purpose.
- Then ask for your content and colours.
The model returns a self-contained HTML file or a component that uses the captured timings and easing. Check it against the Figma timeline and the extension's preview side by side. Recreating a website animation with Claude goes through a full session.
Stage 5: hand off
By now design and code should agree. The handoff is where you make that visible, so the next person to touch the animation knows what is intentional.
- One table of values: track, property, duration, delay, easing, in milliseconds and
cubic-bezier()orlinear(). - The trigger: load, scroll into view, hover or click.
- The reduced-motion behaviour.
- A pointer to the source capture in the designer's My Gallery, by name.
Our post on animation handoff to developers has a fuller motion spec template.
Who does what
| Stage | Usually led by | Output |
|---|---|---|
| Capture | Designer (or whoever found the reference) | Capture JSON |
| Save | Whoever captured it | A named item in My Gallery |
| Refine | Designer | Figma Motion timeline, plus a list of changed values |
| Rebuild | Developer | Component or HTML that uses the captured timings |
| Hand off | Designer and developer together | One agreed table of values |
On a team of one, you do all five. The stages still help, because they stop you from skipping the step where the numbers get written down.
Checklist
- Captured the smallest container that holds the whole motion.
- Triggered it the way a visitor would, at the right window size.
- Checked the preview against the live page.
- Saved the JSON in My Gallery with a clear name.
- Rebuilt it in Figma with your own layers, not the source site's assets.
- Wrote down every timing, easing or track change made in Figma.
- Gave Claude the captured prompt plus those changes, and asked it to keep the rest as given.
- Compared the built version with the Figma timeline and the capture preview.
- Decided and built the reduced-motion version.
- Handed off one table of values, the trigger and the source capture's name.
Starting from the gallery instead
You do not always need a live website. The gallery has crafted animations ready to use. Open a card with View, customize it, and use Copy > JSON (for Figma) for stage 3 and Copy > LLM prompt for stage 4. Save to My Gallery covers stage 2. Your Customize choices carry into every export, so the designer and developer start from the same version. See customizing and exporting a gallery animation.
Questions
Why keep the capture JSON if the design is in Figma?
The JSON holds the original keyframes, durations, delays and easing. The Figma plugin is built from it and the LLM prompt is built from it, so it is the one source both design and code can return to.
Is My Gallery shared between team members?
My Gallery is your own library of captures. To pass a capture to someone else, send them the JSON, the downloaded file or the code, the same way you would share any other file.
Do Figma edits flow back into the code automatically?
Plan for them not to. The plugin turns JSON into a Figma Motion timeline. When the designer changes timing or easing in Figma, write the new values down and include them in the prompt or the handoff note.
Can we start from the gallery instead of a live website?
Yes. Open a gallery card, customize it, and use Copy > JSON (for Figma) for the design step and Copy > LLM prompt for the build step. The rest of the workflow is the same.
