At #Config2026, Figma turned code, motion, and 3D into materials on the canvas, all shipping to production through MCP. The design-to-code handoff is not being optimized. It is being deleted. And motion is the next wall to fall.

Over the last few months at Rango, we kept coming back to one idea. The handoff between design and engineering was the tax. Not the design. Not the code. The gap between them, and the work that went into carrying a file from one side to the other and translating it as it crossed.

It reads as stubbornness. Senior people only. Designers who write their own code, not because the code was the skill, but because it killed the handoff. Nobody in the middle to pass work to.

Yesterday Figma spent its biggest keynote agreeing. And the part most people are skimming past is where it goes next.

What Figma announced at Config 2026

Config 2026 ran June 23 to 25 in San Francisco. It was Figma's first conference as a public company, and the keynote was its clearest statement of direction yet.

The headline is not that Figma added AI. Everyone added AI. The headline is what Figma turned into a material.

CEO Dylan Field framed the whole event around one idea: code, motion, shaders, and generative workflows are materials you shape on the canvas, not separate tools you leave the canvas to use. "Code is material," he wrote, the same as images, vectors, and design layers.

In practice that meant a short list with a long shadow. Code Layers turn any frame into editable, running code that sits next to the design, generated or changed by prompt, then pushed back to your repo. Figma Motion adds a real timeline with keyframes, so animation gets built in the file instead of in a separate tool. Shaders let you describe an effect and get it built. 3D transforms, in preview, add real depth. Weave brings node-based, multi-model generation onto the same surface. And all of it flows to code through Dev Mode and MCP.

Read it back. Frames to code. Motion to code. Effects to code. The file stops being a picture of the product and starts being the product.

One honest note. Code Layers does not ship until July, and Motion is in open beta now. I will not tell you how good Code Layers is until I have built something real with it. But it is good to see Figma moving in this direction, and the direction is what the rest of this is about.

The handoff was always the tax

For years the design file was a drawing. You made the drawing, sent it across a wall, and someone rebuilt it in real code on the other side. Then it came back, you marked up what the rebuild missed, and it went over the wall again.

That wall had a cost. Spec docs. Redlines. Tickets that said "match the Figma." A layer of translation between the people who decided how something should look and the people who made it real. None of that was anyone's fault. It was the structural cost of the work being split in two, and for a long time there was no other way to do it.

I have written this four times now under four names. The middle is the tax. The toll booth was the handoff, not the code. Coding was never the bottleneck. Config was Figma taking that wall down on its own stage, in front of everyone.

Now Figma's own research says it too

Here is the part that made me sit up.

When we started saying the handoff was the real cost, it was a contrarian call. This week the company whose tool sits at the center of the industry said the same thing, in its own words, with its own data.

Field's point that code had been kept apart from the design process is the handoff, named from the inside. Code sat in one place, the design decision sat in another, and the gap between them was the tax.

Figma's 2026 AI report, built on more than 8,000 responses, puts numbers on the rest. The share of designers doing development work doubled in a year to 41 percent. Developers doing design work rose to 60 percent. The roles are collapsing into each other, which is the barbell I described: fewer handoffs because the same person holds both sides.

And on what is left when building gets easy, Figma is blunt. When anyone can build almost anything, the hard part is deciding what is worth building. Ninety percent of the people they surveyed said design matters at least as much as it did before AI. Field said it from the stage another way: AI has made the basic version of anything easy to produce, but the work that stands out at the top still comes from people.

That is the thesis I have been writing these past months, coming back to me in the keynote and the research. The articles did not get louder. The world caught up to them.

Motion is the next wall to fall

Here is what most of the reaction is missing.

The handoff did not fall once, in code. It is a pattern, and motion is the next layer in line.

Think about how motion has worked. You designed a screen, and the moment it needed to move, the work broke. You left your design tool for a harder one. You rebuilt parts from scratch. Then you handed the result to someone else and hoped the final animation still felt like the original idea. Motion was a specialist step at the end.

Figma Motion ends that handoff the same way Code Layers ended the other one. Animation lives on the canvas as a timeline. It can be a component, so it travels across every screen the way fills and type do. In Dev Mode the full timeline is inspectable, and you can copy it as CSS, JSON, or React, or pass it to a coding agent through MCP so nothing gets reinterpreted on the way to production.

I am not the only one calling this a handoff. Atlassian's Alexandra Pereira described Figma Motion as taking animation "from a specialist handoff into a system capability." Jitter, a tool built entirely to put motion inside the design process, welcomed the move and described the old reality plainly: animation had always been kept just outside design, picked up late and handed off. Two companies on opposite sides of this market, naming the same wall I have been naming.

Why video is the biggest one

I learned this the way I learn most things, by doing it myself. I edited a video recently, went looking for tools, and fell into an entire universe of AI-powered motion and video software I did not know existed. It is moving faster than almost anything in design right now.

There is a reason. Code is how products get built. Motion and video are how everything gets seen. People watch more than they read. A brand lives or dies in a feed full of motion, where a still frame slides past and a moving one stops the thumb. Video is the format consumer attention actually runs on, which makes it the largest surface AI has left to take.

So the order is becoming clear. AI came for the developers first, because that is where the AI companies aimed. The tools that proved AI could do real work were built for code: Copilot, then Cursor, Codex, Claude Code. Coding is where these models found their first real market, and most developers now build with these tools. That was the most obvious wall to take down. Motion is falling now, on the same canvas, for the same reason. And video, the broadest and most consumer-facing layer of all, is where the next few years of this go. The teams who treat motion and video as a system built into the work, not a step bolted on at the end, are the ones who move while everyone else waits for a handoff.

A more powerful tool is not fewer handoffs

One caution, because it is easy to read all of this as "use the most powerful canvas and you win."

A more capable tool is not the same thing as fewer handoffs. Figma is pulling code, motion, depth, shaders, and generation onto one surface so you never leave it. Parts of that are very good, and we use them. But a thicker tool in the middle is still a tool in the middle. A canvas that wants to be your entire pipeline is a bigger dependency, not a smaller one.

The prize was never owning the most capable canvas. It was holding the whole thing, end to end, with judgment at every step. Those are different bets. One says the answer is a better surface. The other says the answer is fewer surfaces and better people.

We still use Figma every day. For thinking, for the system, for taste. Then the system becomes code, and the code ships. The tool stays in its lane, and the work moves through it instead of stopping inside it.

What stays scarce

The tools are all converging on the same trick. Generate the thing, push it to code, skip the wall. Figma, the model labs, the new motion and video apps, all of them racing to the same place. Soon that part is free and everywhere.

What does not get cheap is knowing what to build. What matters first. What to cut. Which version is actually good and which one only looks finished. Figma's own research landed on the same point this week: when anyone can build almost anything, the hard part is choosing what deserves to ship. That judgment was always the scarce thing, and it is the one thing none of these announcements touch.

Config did not change what the work is. It cleared away everything that used to hide it.