iFMade with iterFact™
Architectural deep read

Figma MCP vs iterFact —
two different games.

Both ship MCP servers. Both claim design-system-as-source-of-truth. Both work with Claude Code and Cursor. They solve fundamentally different problems and live in different market layers. This is the architectural read — and where the bridge between them becomes a distribution channel.

01 — The core difference

One sentence decides everything.

The thesis

Figma MCP exposes an existing artifact so agents can read and modify it.
iterFact MCP is the production pipeline — prompt in, hosted artifact URL out.

Figma's MCP is a context bridge. A designer makes a file; the server streams its structure (layers, variables, components, auto-layout, tokens) to an agent; the agent writes code. Figma is never the delivery surface. The deliverable lives in an IDE or back on the Figma canvas.

iterFact's MCP is a render pipeline. A prompt enters; the planner picks engines; the deterministic assembler renders HTML/CSS/JS; the artifact is hosted at a.iterfact.com/... on Cloudflare R2 with zero egress. The URL is the product.

02 — How figma mcp works

Context bridge, not output factory.

Figma MCP — data flow
mcp.figma.com/mcp
SOURCEMCP SERVERAGENTDELIVERYFigma filedesign system lives here— layers, frames— variables, tokens— components— auto-layout— Code Connect mapFigma MCPOAuth · Streamable HTTPREADget_design_contextget_metadataget_screenshotget_variable_defsget_code_connect_mapWRITEuse_figma (JS)create_new_filegenerate_diagramsend_code_connect~10 tools totalLLM AgentClaude Code · CursorCodex · VS Codeinterprets contextwrites codeIDE / CodebaseReact + Tailwind(default output)lands in your repoFigma canvaswrite-to-canvasvia Plugin APIframes · vars · componentsreadwritecodeuse_figmaAccess gateStarter: 6 calls/month · Dev seat: read-only · Full seat: read + write · Write-to-canvas free during beta, usage-paid later

The flow requires a designed Figma file as precondition. Without it, there's nothing to extract. Code Connect is the secret sauce — it maps Figma nodes to real code components in your repo, so the generated code uses your actual imports and prop interfaces, not generic React. That's the genuine strength, and iterFact has no analog.

03 — How iterFact works

Prompt enters. URL exits.

iterFact MCP — data flow
mcp.iterfact.com/mcp
INPUTPIPELINERENDERDELIVERYPrompt · Datafrom anyone, any source— natural language— structured JSON— API responses— CSV / spreadsheet— (future) Figma ctxiterFact MCPchunked async build01 · PLANcreate_artifact_draft(LLM plans sections)02 · BUILDappend_section(deterministic engines)03 · SHIPfinalize_artifact(critic + publish)04 · POLLget_artifact_status38 enginesdeterministic assemblerdashboard-kpiwaterfall-charttestimonialsranking-chartscatter-explorertreemapsankey-flowweather-brief... 30 moredesign system baked inPride & Care v4 · 7 BPDM Serif + DM Sansa.iterfact.comCloudflare R2 hosted— zero egress fees— shareable URL— embeddable anywhereDisplay slotstable URL, hot-swapiterfact.com/@paul/...artifact swaps underneath← differentiatorAccessFree: 10 artifacts/mo · Starter $49: 15 (76% margin) · Pro $149: 50 (56% margin) · SDK: $0.10–$0.50/gen · template path cost: $0.07

Two things worth flagging. The engines are code, not prompts. The LLM plans; the render is deterministic. Same input → identical output. That's structural, and it's the thing Figma can't copy without rebuilding their entire output layer. Second: the display slot. A stable URL with a hot-swappable artifact underneath is a primitive Figma has nothing analogous to — because hosting was never their game.

04 — Side by side

The dimensions that matter.

Dimension
Figma MCP
iterFact
Endpoint
mcp.figma.com/mcp
+ desktop at 127.0.0.1:3845
mcp.iterfact.com
Required input
A designed Figma file. Without one, nothing to extract.
A prompt, or structured data. Zero prerequisites.
Delivery surface
IDE (code) or Figma canvas. Figma isn't a CDN.
Hosted URL at a.iterfact.com. The URL is the product.
Determinism
LLM end-to-end. Same prompt → different output. Skills try to stabilize this.
LLM plans. Engines render. Deterministic at the critical step.
Design system
Your team maintains it in Figma. Code Connect maps to your codebase.
Pride & Care v4 baked into all 38 engines. Works with zero setup.
End user
Developers with a designer on staff.
Anyone who needs a published interactive doc.
Render target
Source code (React + Tailwind default, customizable).
Self-contained HTML/CSS/JS artifact, hosted.
Free tier
6 tool calls per month on Starter. Practically a demo.
10 artifacts per month. Usable as on-ramp.
Pricing axis
Seat-based ($15/user/mo Pro) + usage-paid write coming post-beta.
Artifact-count SaaS + SDK per-generation ($0.10–$0.50).
Write tools
use_figma runs JS against Plugin API. Writes frames, variables, components.
append_section + finalize_artifact. Writes hosted HTML artifacts.
Structural moat
20M+ existing designers. Code Connect to codebases. Microsoft/OpenAI partnerships.
R2 zero-egress hosting. Deterministic engines. Display slot primitive.
05 — Where each is structurally stronger

Honest read on advantages.

Figma structural advantages

What they do that you can't.

  • ✓20M+ existing designers. Distribution already exists. Every team with a Figma file is a latent user.
  • ✓Code Connect. Genuine killer feature — maps Figma nodes to your actual codebase components. No iterFact analog.
  • ✓Microsoft/OpenAI partnerships. Codex, VS Code, Copilot — all deep integrated. Platform-level distribution.
  • ✓Canvas as write target. For design teams, editable Figma frames beat static HTML. Different use case.
  • ✓Bidirectional workflow. Code → canvas via capture tools, canvas → code via context. Full loop.
iterFact structural advantages

What you do that they can't.

  • ✓Deterministic render. Engines are code. Same input = same output. They'd have to rebuild their entire output layer to copy this.
  • ✓R2 zero-egress hosting. Embed anywhere, ship anywhere. Figma would have to become a CDN company.
  • ✓No pre-existing design infrastructure required. Their flywheel needs mature Figma files + Code Connect. Yours runs on a prompt.
  • ✓Display slot primitive. Stable URL with hot-swap artifact underneath — no analog in Figma's world.
  • ✓Output-based pricing. No seat gates. Aligns price with delivered value. Friendlier to non-devs.
  • ✓Same surface serves everyone. Dev, analyst, RE agent, finance ops — all get hosted interactive docs from the same pipe.
06 — The bridge

figma_to_iterfact — engine 44.

Here's where these two products stop being comparison and start being stack. Figma has 20M+ users sitting on design files that eventually need to become published interactive artifacts. That last step is exactly what Figma doesn't do. A bridge engine turns Figma's user base into an iterFact distribution channel.

The pitch

"Paste a Figma URL. Get a hosted interactive artifact."

Pull Figma design context through Figma's own MCP. Map variables → iterFact tokens. Map components → iterFact engines. Render through the deterministic assembler. Publish to a.iterfact.com. Done.

Bridge architecture — figma_to_iterfact engine
cross-MCP composition
01 · SOURCE02 · EXTRACT03 · MAP & RENDER04 · PUBLISHFigma URLuser pastes linkfigma.com/design/...?node-id=1-2Figma MCPcalled by iterFactget_design_contextget_variable_defsget_metadatareturns:— tokens (colors, type)— frame tree + layoutengine 44figma_to_iterfacttoken mapperFigma vars → P&C v4(or use Figma's as-is)layout classifierframe type → enginedashboard? kpi-gridchart? waterfall/rankquotes? testimonialscontent extractortext + numbers fromFigma node tree→ normal iterFact builda.iterfact.comhosted artifact— interactive HTML— responsive, 7 BP— embeddable— shareable URL— print readywhat Figma can't doWhy this is asymmetricFigma gets nothing from this bridge — they don't host artifacts, they don't care about the output surface.iterFact gets: (1) latent user base of 20M designers, (2) free quality signal from Figma files, (3) zero-setup adoption path

Implementation sketch

# engine 44 pseudocode — lives inside iterFactdeffigma_to_iterfact(figma_url, options): # 1. Call Figma MCP from our side (OAuth handoff) context = figma_mcp.get_design_context( fileKey=extract_file_key(figma_url), nodeId=extract_node_id(figma_url), ) variables = figma_mcp.get_variable_defs(...) # 2. Classify: what kind of artifact does this Figma file represent? artifact_type = classify_layout(context) # → "dashboard" | "pitch_deck" | "report" | "landing_page" | ...# 3. Map: decide which iterFact engines render which Figma frames section_plan = map_frames_to_engines(context, artifact_type) # → [{engine: "dashboard-kpi", data: {...}}, ...]# 4. Token handoff: honor Figma design intent OR use P&C v4 tokens = options.use_figma_tokens ? port_figma_variables(variables) : pride_and_care_v4 # 5. Normal iterFact chunked build from here draft = iterfact.create_artifact_draft(plan=section_plan, tokens=tokens) for section in section_plan: iterfact.append_section(draft.id, section) return iterfact.finalize_artifact(draft.id) # → returns https://a.iterfact.com/{id} ready to share
07 — Strategic read

What this means for Billy.

  1. Figma validates the MCP-native thesis. use_figma shipping proves write-tools are real product, not toy. The "beta free → usage-paid" arc is the default pricing path for MCP services. Charge without apology.
  2. Skills vs engines is the real fight. Figma's skills are markdown-prompt-layer glue; yours are deterministic code. When Sonnet 5 ships, their outputs drift, yours don't. Lean into determinism in every marketing surface — "same input, same output, always" is a developer magnet.
  3. Design-system-free onboarding is your distribution moat. Figma's flywheel needs mature files + Code Connect. Yours runs from a sentence. The unhedged message: "you don't need Figma, you don't need a designer, you don't need a design system — paste a prompt, get a URL."
  4. The bridge is a distribution channel, not a competitor. figma_to_iterfact engine taps 20M designers who already have source material. Figma can't build the reverse because they don't host. Ship the engine, add a one-click "Publish this Figma file to an iterFact URL" button. Every design file in the world becomes a latent top-of-funnel.
  5. Code Connect is a genuine gap — consider an analog. "iterFact Code Connect" would map user-defined component libraries to iterFact engines, letting teams customize renders without losing determinism. Lower priority than the bridge, but the blueprint is already proven.
  6. The free tier disparity matters. 6 calls/month is a gate users resent. 10 artifacts/month is an on-ramp. Your free tier is a better acquisition channel than theirs — lean on it in comparison content. Don't lower free tier; raise perceived generosity via messaging.
  7. Hosting is the one thing they structurally can't copy without becoming a different company. R2 + zero egress is more defensible than it looks. Every time someone asks "how do I share this?", Figma's answer is "open the file" and yours is "send the URL." That's not a minor UX difference; that's the whole game.