WeXL Forge · Design · Beta

Forge Screens

Turns a Figma frame or screenshot into screens on your design system

Takes
Figma frame linkScreenshot or mock-up (.png, .jpg)Your design system's component list
Gives
Screen code built from your componentsA list of gaps: elements with no matching componentOpen questions on states and behaviour
Updated
Draft

The problem

A designer hands over a Figma frame. A front-end developer opens it next to the editor and rebuilds it by hand: picks the layout, finds the button, the table and the form field in the team’s component library, wires up the props, and guesses at the states the frame does not show. It is careful, repetitive work, and on a project with dozens of screens it eats a large share of front-end time.

The generic shortcut makes it worse. Figma-to-code tools and chatbots will turn a picture into markup, but they write their own markup. You get a page of hand-rolled divs and inline styles that looks right in a screenshot and ignores the design system the team spent months building. Someone then has to rip it out and redo it with the real components, or, more often, it ships, and the design system starts to drift one screen at a time.

Good looks like this: the screen is built only from components that already exist in your library, with their real props and tokens; where the design asks for something the library does not have, that is called out rather than faked; and the states the frame leaves out (empty, loading, error) are raised as questions before anyone writes them.

How it works

Forge Screens reads one screen per run: a Figma frame by link, or a screenshot or mock-up image. It also reads your design system’s component list, which names each component, what it is for and the props it accepts. That list is the agent’s whole vocabulary.

It builds the screen as a structure of those components: layout first, then each element mapped to the closest component and filled in with props, text and design tokens. The approach follows a simple rule: the model may only pick from the catalog. It cannot write a new component, add inline styles or reach for a library you do not use.

Then it is checked. The output must validate against the component list before it is rendered: an unknown component or an invalid prop is rejected, not shown. What the agent could not match goes into a separate gaps list, for example “date range picker: no matching component; closest is DatePicker, which takes one date”. States and behaviour the image cannot show go into open questions.

A person then reviews it. In practice that is the front-end developer who owns the screen, with the designer looking at the gaps. The developer gets a starting point that already uses the team’s components, and the designer gets an early list of where the design and the library disagree.

The pattern suits a component library built on something like shadcn/ui, where each component is a known file with typed props. If your design system is documented in Storybook or a similar catalog, that is usually enough to build the component list from.

Where it gets it wrong

Forge Screens is good at assembly. It is not a designer, and it fails in predictable ways.

  • It picks the wrong near-match. A design element that sits between two components (a card that looks like a list item, a tag that looks like a button) can be mapped to the one the designer did not mean. Every mapping is visible in the output, so a reviewer can see the choice and change it.
  • A screenshot hides intent. An image does not say what is clickable, what scrolls, or what happens on hover. A Figma frame with named layers and auto-layout gives the agent more to go on than a flat image. When it has to guess, the guess goes in the open questions.
  • It only knows the states it can see. Empty lists, long names, errors and loading states are rarely in the frame. The agent lists them rather than inventing a design for them.
  • A thin component list gives thin results. If the library is undocumented or the props are unclear, the agent has less to work with and more ends up in the gaps list. Part of setting it up is writing that list properly, which is useful to the team anyway.

We would rather it report a gap than fake a component. A faked component is exactly the drift the design system exists to prevent.

Why not just prompt a chatbot

A chatbot will turn a screenshot into plausible front-end code in seconds, written with whatever markup it likes. That is the problem it creates, not the one you have. What makes Forge Screens useful is the constraint: the component list it is held to, the check that rejects anything outside it, and the gaps list that tells the designer where the library falls short. That steering, fitted to your design system, is the work, and it is what you keep.

What you get

  • In your engagement: Forge Screens builds first drafts of screens on your design system, and your front-end developers review and finish them instead of starting from a blank file.
  • Under your brand: services firms can offer it inside their own delivery platform, pointed at each client’s component library.
  • Built to own: we fit it to your design system, component list and front-end stack, and hand over the source.

See three ways to use an agent.

Run it on your input.

Send us a real Figma frame or screenshot. We run Forge Screens on it and send the output back within one working day, with a note on what we would change for your setup.

Start here

See Forge on your own codebase.

Start a conversationWe'll show the Live agents on a real workflow of yours.