Figma is excellent. We’ve shipped real work in it for years, and this isn’t a “Figma is dead” post — it very much isn’t. The fact that we built an open-source layer instead of another canvas isn’t a complaint about Figma’s craft. It’s a bet that the next decade of design work looks less like a cursor on an infinite canvas and more like an agent you already pay for, driving a workflow you actually own. This post is the honest read on Figma from a team building in the same category: what it does best, where it locks you in, what the open-source path actually looks like, and which one you should reach for this quarter.

What Figma actually is

Figma is the default collaborative design tool. A real-time multiplayer canvas in the browser, with Dev Mode for handoff, FigJam for whiteboarding, a deep plugin marketplace, and a growing set of AI features bolted onto the same surface. Pricing is per-seat per-month, tiered by role and by org.

It does a handful of things better than anything else:

• Real-time canvas collaboration. Five people in one file, cursors live, comments inline. Nothing in open source matches the multiplayer polish.
• Pixel-precise vector work. Auto Layout, constraints, variants, components — the canvas primitives are mature and the muscle memory runs deep.
• A huge plugin ecosystem. A decade of third-party plugins, community files, and templates you can drop in.
• Handoff that teams already know. Dev Mode, inspect, redlines, and a workflow engineering has been trained on for years.

If your work is a designer painting precise screens for other humans to review on a shared canvas, Figma is still the answer, and it’s a good one. The differences worth caring about live one layer down — in who owns the file, the workflow, and the cost curve.

Where it locks you in

Figma carries four pieces of lock-in worth naming upfront, because the pricing pages don’t.

The file is proprietary. Your design lives in Figma’s format, inside Figma’s servers. You can export PNGs and dev specs, but the source of truth — components, variants, the live design system — is only fully legible inside Figma. There is no plain-text version of your work that survives the tool.

The runtime is hosted. The canvas is the cloud. For agency work or pre-launch creative under NDA, “where does this file live” is a procurement conversation, not a setting. Local-only isn’t a mode.

The plugins aren’t portable. Figma’s plugin ecosystem is real and deep — but every plugin runs inside Figma’s runtime, against Figma’s API. A workflow you build there can’t be lifted out and run by an agent on your laptop, or composed into a pipeline that doesn’t start with the Figma canvas.

The bill is per-seat, forever. Subscription seats are fine for a stable design team. They get awkward for a fast-growing org, and they’re a non-starter for the long tail of contributors, contractors, and one-off collaborators who’d otherwise pick up the same workflow.

None of these are bugs. They’re the shape of a hosted, collaborative-canvas product, and Figma is the best version of that shape. We’re just not building for the canvas — we’re building for the agent.

The shift Open Design bets on

Open Design isn’t a Figma clone. There’s no infinite canvas and no multiplayer cursors. It’s a thin skill layer that turns the coding agent you already use into a design engine. The four primitives are skills, systems, adapters, and the daemon — and the important part is that they’re all just files:

• Every skill is a SKILL.md file you can read, fork, and send back as a PR.
• Every design system is a portable DESIGN.md file — including the one we ship for Figma itself. You can open it in any editor, diff it in git, and it outlives whatever tool reads it next.
• Every agent adapter is ~80 lines of TypeScript.

What that buys you is the opposite of the four lock-ins above:

• The file is plain text. Skills and systems are Markdown in a repo. Your design system is legible without the tool.
• The runtime is local. It runs on your laptop via pnpm tools-dev, or you deploy it yourself. Prompts go to the model provider you chose — nothing routes through us.
• The workflow is portable. A skill is a folder. It composes into any agent on your $PATH, not a single vendor’s plugin runtime.
• BYOK by default. Paste any OpenAI-compatible base_url and key; your tokens go straight to the provider. Apache-2.0, no signup, no per-seat bill.

The mental model: Figma is a canvas you rent. Open Design is a workflow you own.

Side-by-side

	Figma	Open Design
License	Proprietary	Apache-2.0
Runtime	Hosted (browser, Figma cloud)	Local daemon (pnpm tools-dev) + optional self-host
Source format	Proprietary .fig	Plain-text SKILL.md / DESIGN.md in a repo
Primary surface	Real-time multiplayer canvas	Agent-driven generation + sandboxed preview
Models / AI	Figma’s own AI features	Any OpenAI-compatible endpoint + detected coding-agent CLIs
Plugins	Marketplace, runs inside Figma	Forkable skill folders, run by any agent
Design systems	Figma libraries (in-tool)	Portable DESIGN.md files (incl. a Figma one)
Pricing	Per-seat subscription	Free; you pay your model provider directly
Handoff	Dev Mode, inspect, redlines	Any agent on $PATH, plus HTML / PDF / PPTX / ZIP exports
Self-hostable	No	Yes (laptop or your own deploy)
Data path	Files → Figma cloud	Prompts → your chosen provider; nothing through us

The honest summary: Figma has the most polished collaborative-canvas experience on the market, and for a team of designers reviewing precise screens together, that polish is the product. Open Design trades the canvas entirely for a library — skills, systems, and agents designed to compose with the tool already on your laptop. Different shape, different bet.

Who should pick what

If you are…	Pick
A design team doing real-time, multi-designer canvas work with live review	Figma. Nothing in open source matches the multiplayer canvas.
A designer doing pixel-precise vector and component work all day	Figma. The canvas primitives are mature and your muscle memory is worth real money.
An org already standardised on Figma with Dev Mode in the engineering loop	Figma. You’ve paid the integration cost; spend it.
A design engineer who already drives Claude Code, Codex, or Cursor from the terminal	Open Design. Your agent is the design engine; the skill layer adds taste and structure without a new app.
Anyone who needs BYOK, model choice mid-project, or local-only for sensitive briefs	Open Design. The reality is rougher than the marketing, but it’s the only contract that actually holds.
A team that wants a design system that survives tool churn	Open Design. DESIGN.md files outlive the tool that reads them.
An open-source contributor who wants to ship a design workflow the project can adopt	Open Design. Drop a folder, restart the daemon, send the PR.

The dimension that decides it for most teams isn’t quality — Figma’s craft is real. It’s whether your work is a canvas to paint on, or a workflow to automate. If it’s the latter, you’d rather own it than rent it.

What to do next

If you already have a repeatable Figma job — export these frames, sync those tokens, rebuild that deck template — the fastest way to feel the difference is to port one of them into a plugin. Start with one annoying, repeatable task, not “replace Figma.”

Or just run the three-command quickstart and point it at the model you already pay for. The whole thing lives in one repo and the first deck takes about ten minutes.

Try the open-source workflow.

• How to port a Figma workflow into an Open Design plugin — the concrete path for an export, token sync, or brand kit
• The open-source alternative to Claude Design — the same honest read, one tool over
• Why we built Open Design as a skill layer, not a product — the longer manifesto behind the “layer, not product” bet

Next step

Run the skill workflow locally

Browse the workflow library, pick a starting point, and wire it into the agent you already use. Join our Discord if you want help adapting it.