Design Forge turns a plain-English prompt into a fully built, editable design system, color, typography, components, motion. What used to take a designer a full day of setup happens in minutes. Every output is a real system, not a moodboard: tokens you can export, components you can drop into Figma, motion rules that behave the same way across every screen.
I designed and built it end-to-end. Research with practicing designers, the generation logic, the editing model, the export layer. The sections below trace the project from why systems take so long to build, to the architecture that lets one prompt produce something coherent enough to ship.
Every project starts from a blank file.
Most design work doesn’t start with design. It starts with setup, defining tokens, building a button library, agreeing on a type ramp, naming spacing values. The work that determines whether a product feels coherent is also the work designers least want to do, and the work they redo on every project.
Existing tools don’t help. They translate shapes, rectangles, frames, components, but not intent. A designer who knows exactly what they want still has to manually assemble the system that expresses it. The translation step is where days vanish and where consistency quietly breaks down.
The hidden cost of building a system from scratch.
I interviewed 12 working product designers and surveyed 47 more to quantify what setup actually costs. The number that came back surprised even the designers themselves: a typical base system takes 7.5 to 15 hours to build before meaningful product design can begin. The median was just under 10. That cost repeats on every new product, and it’s paid silently, it never shows up on a roadmap.
User journey map.
The before-state is hours of assembly. The after-state is minutes of editing. Each step marks a moment the designer actually lives through, where friction used to live, and where it doesn’t anymore.
Systems should be generated, not assembled.
The gap isn’t between designers and tools. It’s between intent and execution. A designer can describe what a product should feel like in a sentence, calm, dense, playful, clinical, but spends hours translating that sentence into a system one decision at a time.
Language is the most natural design input we have. If a designer can describe the product, the system should be inferable from the description. Generation isn’t a shortcut around craft, it’s a way to skip past assembly and get to the part where craft actually shows up: editing, refining, deciding what’s wrong.
One prompt in. A complete system out.
Design Forge reads a single prompt, infers the intent behind it, industry, tone, audience, density, emotional register, and assembles a complete design system around that intent. Color, type, components, motion. Generated together so they hold together.
What makes it different: every output is editable at the system level, not the artwork level. Change the primary color and every component, state, and motion that depends on it updates in place. The system stays coherent without a designer manually keeping it that way.
Information architecture.
One input surface, one generator, one editable system, one exit. Each column is a layer in the product; the engine runs the propagation logic between them so the designer can stay in intent mode.
Low-fi screens before any styling.
Four screens to argue with the flow before picking a single typeface, prompt, generated tokens, component preview, and handoff. If the grey-box version read clearly, I earned the right to add ink.
Five moments that hold the product together.
Each feature solves a specific failure mode from the research, repetition, drift, lost intent. Tap a feature to see what it does and why it’s built that way.
Prompt to system in six steps.
The flow is intentionally short. The harder the input gets, the less the product gets used. Every step earns its place, anything that didn’t pull weight got cut before high-fidelity.
Designer writes a sentence. Industry, tone, audience, anything that helps.
The whole flow, first prompt to working Figma library, runs in under five minutes. Most of that is the designer reading what was generated.
Four trade-offs the product is built around.
Every feature was tested against these. They aren’t principles on a slide, they’re the calls I had to make repeatedly during build, often choosing the harder side. Tap one to see why.
Technical thinking.
The architecture had to do two things at once: generate output that’s coherent on first pass, and stay editable at every layer afterward. Four ideas hold the system together.
What changes when setup stops being the work.
The point isn’t generation for its own sake, it’s what designers can do once they stop spending the first day of every project assembling primitives. The shift is structural, not cosmetic.
What the process taught me.
The hardest part wasn’t generation. It was deciding what not to generate. The first version produced too much, every state, every variant, every motion curve, and designers spent more time pruning than building. Restraint became a feature: generate the core, leave the rest as space the designer fills.
The second lesson was that token architecture is the actual product. The visible UI is the surface; the system underneath is what makes the output usable. Every hour spent on naming and inheritance returned ten in editing.
What’s next: bidirectional editing, where changes inside Figma propagate back to the source system; multi-product workspaces, so one brand can host many systems without duplicating tokens; and a code export layer so engineering inherits the same source of truth as design.