Dylan Field posted about a new Figma feature: the ability to bring work from Claude Code directly into Figma’s canvas. Capture a working UI - something that already works in production, staging, or localhost - and convert it into editable Figma frames.
Let’s break that down. You use an AI coding tool to generate a working interface. Real code, real interactions, and real data. Then take the functioning reality and convert it back into a static abstraction, so that people can look at it together on that canvas.
You had a building. Now you have an architect’s drawing of that building.
Figma is telling you this is progress. It isn’t. It’s a solution to Figma’s business problem - the growing irrelevance of the static canvas - presented as though it’s a solution to yours.
In November I wrote about the collapse of the traditional digital workflow. That comfortable fiction where design happens here, code happens over there, and a handoff ritual connects the two.
AI is dissolving that middle layer. Structured design systems, and wider product context, can be interpreted into working interfaces. At that point, the abstraction layer between design intent and delivery reality becomes unnecessary. Design isn’t a stage before delivery. Design is delivery.
It’s a defining shift in how products get built.
Jonny Burch made a complementary argument last week, in his piece “Life After Figma is Coming.” His framing encompasses the tooling ecosystem: as code becomes the source of truth, design tools become interfaces on code, not the other way around. Code is the only correct source of truth - open, shared, with common standards. The canvas doesn’t disappear, but it has to become a view into reality and not a substitute for it.
These arguments point in the same direction. The canvas is no longer a staging ground for ideas that exist outside the system. It needs to be a live interface for ideas that exist within it.
Claude Code to Figma points in the opposite direction entirely.
Field’s own framing is revealing. He describes working code as “tunnel vision” and that this feature will help you “escape” it.
…the design canvas is better at navigating lots of possibilities than prompting in an IDE.
The Figma blog announcing the Claude Code to Figma feature elaborates further. Solo code exploration is a “single-player environment”.
…that speed of solo exploration can become a constraint.
And as a contrast, they describe the canvas as a “shared space” where “the conversation changes and new possibilities open up.”
That’s a neat rhetorical move.
It takes a genuine limitation of current code-first workflows - collaboration and visual comparison are harder in a terminal - but reframes it so that the working artifact is the problem, and the abstraction is the solution.
Those are not the same thing. Needing better collaboration on working artifacts isn’t the same as needing to convert the artifacts into a different, lower-fidelity format in order to collaborate at all.
The answer to “how do we collaborate on code?” is not “convert it to not-code.”
The better solution is better collaboration tooling for code. Live preview sharing. Annotation layers on running applications. Structured feedback on deployed states. As Burch points out, a tooling ecosystem is already exploding in size - design interfaces that sit on top of production code, development environments that integrate design thinking. The pieces are coming together.
When you capture something from Claude Code and bring it into Figma you don’t add information. You remove it. You remove interactions, real data, actual behavior. You replace it with a picture of what it looked like at the moment of capture.
That’s trading truth for convenience, and claiming it’s a workflow improvement.
It’s an absurd proposition.
You have a working thing. You convert it into a non-working representation. You collaborate on the representation. At some point, presumably, someone has to make into a working thing again. That’s not a workflow, that’s a detour.
This is not just a feature decision. It’s a strategic posture that serves Figma’s interests while actively working against the interests of people using it.
Figma’s business depends on it being the place where product decisions happen. Their value proposition is the collaborative canvas being the hub of product development. The more decisions happen in code-first environments - engineers and designers collaborating directly on running applications - the more Figma risks becoming peripheral.
Figma is trying to maintain its gravitational pull. Every feature needs to bring work into Figma, not enable work to happen outside it.
Field says this directly:
Whether product building begins in a terminal, a prompt box, a visual UI or a hand-drawn sketch, we want Figma to be the place where it all comes together.
That’s not a workflow insight. That’s a business objective.
Claude Code to Figma is not about improving your workflow. It’s about preventing your workflow from leaving Figma behind.
And this is the part of the framing that I find genuinely dishonest. Figma’s blog post presents this as a way to unlock creativity and open up collaboration. Something to liberate teams from the constraints of solo code exploration. But the people who are using Claude Code to build working interfaces aren’t constrained. They are ahead. They have the real thing. The feature asks them to go backwards. Sacrifice fidelity, leave something functional and return to an abstraction layer. Because Figma needs them to.
That’s a solution for Figma. It’s not a solution for the people building products.
The timing might reinforce the point. Figma went public, and the stock has dropped a lot since IPO. It’s a legitimate question whether AI-native tools make traditional design canvas less central to digital product development. So product announcements also need to be a message to investors: the canvas is still essential.
Code-to-canvas is a defensive move dressed up as innovation.
The honest version of this feature announcement might say: “More product work is starting in code. We need to pull that back into our ecosystem so we can remain relevant.” That’s a legitimate business challenge. And I have sympathy for the difficulty of Figma’s position. They built something genuinely great, and the ground is shifting beneath it.
But don’t tell me it’s for my benefit. The loss of fidelity isn’t “opening up new possibilities.” A functioning prototype being flattened into a picture isn’t “changing the conversation”. The conversation was already happening - and in a richer, more honest medium. This feature interrupts the conversation to bring it back to Figma.
It’s not about fewer canvases. It’s about more honest ones. More real. Connected to live systems, reflecting real state. Enabling collaboration on the actual artifact rather than a simulation. The future of the canvas is as an interface to code, not a destination to convert code back to.
Code to canvas is the wrong direction. The future is canvas as code. Features like this are going to look increasingly strange as the rest of industry figures that out.
I’m not a neutral observer.
I’m VP of Product at Knapsack. We’re building in the place where structured design systems and product context meet AI-driven delivery.
But the proximity is also why this absurd code-to-canvas direction is so acute for me. When you’re working on systems that make design directly executable, watching someone propose converting execution back into abstraction feels like someone printing out a Google Doc so that they can fax it.
I'm presenting an expanded version of these ideas at the Great International Developer Summit in April 2026.
Further reading:
The digital workflow is obsolete - the end of abstraction, and the start of design as delivery.
Burch, J. Life after Figma is coming (and it will be glorious). jonnyburch.com, Feb 2026.
Seiz, G. & Kern, A. From Claude Code to Figma: Turning production code into editable Figma designs. Shortcut - Figma’s editorial newsletter, Feb 2026.
Field, D. Claude Code to Figma Design. LinkedIn, Feb 2026.
Flowers, E. If you ask a designer what they want, they will say faster horses. Zero Vector, Feb 2026.
Article photo by Rob Martin on Unsplash.