Your Design Tool Just Learned to Code, Test, and Click

Your tools are eating the space between design and shipping. Figma now runs code on the canvas. Gemini can drive a browser. Cursor lets AI iterate on your codebase in the background without touching your work. The line between "designed" and "built" is getting thin, and that changes what your team makes in-house versus buys. Let me catch you up.

The canvas that runs code

Figma added a code layer to the collaborative canvas, plus support for animations, transitions, and 3D transforms. Designers used to build motion in other software and convert it to code the app could read. Now it lives in Figma directly.

The point is not clean production code. Chief product officer Yuhki Yamashita said the multiplayer canvas is powerful because "you don't really care about the quality of the code". It is a place to explore fast and try a bunch of directions. Teams can clone repos and pull flows from code into design layers for testing.

That shifts who touches what. Designers, PMs, and engineers can iterate in one spot before anyone writes real code. Your handoff doc gets shorter because the exploration already happened together.

When the software can use software

Google put computer use into Gemini 3.5 Flash as a built-in tool. It was a standalone model before. Now the main Flash model can "see, reason and take action across browser, mobile and desktop environments".

The use case that should catch your eye is continuous software testing. Google showed the model auditing its own documentation for accessibility issues and returning a categorized list of app features. An agent that clicks through your product and flags problems is a QA function you might have staffed or outsourced.

Before you point it at anything live, note the risk. Google flags prompt injection and ships two optional guardrails: require user confirmation for irreversible actions, and auto-stop a task if an injection is detected. They recommend sandboxing and human review on top. Handy, and also a warning about what can go wrong.

The work that happens where you can't see it

Cursor built what it calls a shadow workspace so AI can iterate on code without breaking your session. The plain version: naively letting AI loose in your folder "results in chaos," like overwriting a function you just wrote. So the AI edits in a hidden window, gets lint errors, and refines its guess before you ever see it.

Why it matters: giving AI lint feedback is one of the biggest ways to improve its code, going from 90 percent working to 100 percent. The catch is honest. Rust support is not there yet, because rust-analyzer needs files written to disk. Runnability, actually executing the code, is still unbuilt. The hard part is the plumbing, not the model.

The roadmap they keep publishing

Read Cursor's problem lists and you see the direction. They want to predict your next action across the codebase, your next file, your next terminal command, not just your next keystroke. And they want background agents you can trust with a unit of work while you keep moving.

The earlier list is more concrete about scale: 1.4 billion vectors and 150 thousand codebases indexed as of October 2023, with a custom reranker pulling 500k tokens down to the 8k that matter. Bug-finding runs in two modes, a passive background scan and an active partner during debugging.

Stack these against Figma and Gemini and the pattern is clear. Design explores in code. Agents test the running product. Coding tools handle the grunt edits in the background. Your pipeline compresses.

The deep cut

The thing to catch: these tools are absorbing tasks you currently scope as separate jobs. Motion work, accessibility audits, QA passes, small refactors, spec-heavy handoffs. Each one is being folded into a tool your team already pays for.

So the build-versus-buy call is not about buying a new tool. It is about not building a workflow around a gap that is closing. If you are about to hire for QA automation or write a heavy design-to-dev handoff process, wait. Run a two-week pilot with the agent features first. You may be spending headcount and process on a problem your license already solves. And keep a human on the confirm step for anything irreversible, because the injection risk is real.

Three questions for your team

1. Which handoff step could Figma's code layers absorb, and what does our spec doc look like once designers and engineers explore together on the canvas?
2. Before we staff QA or accessibility auditing, can a Gemini computer-use agent do a first pass, and what human confirmation gate do we put on any live action?
3. Where are we about to build process or hire around a task that Cursor-style background agents are already closing, and can we run a short pilot before we commit?