For years, frontend tooling has been obsessed with one question:
"How do we convert designs into code faster?"
Personally, I think we've been asking the wrong question.
Modern AI can already generate interfaces, scaffold components, and even produce decent production-ready code. Yet one frustrating problem remains largely unsolved: what happens when the code becomes the source of truth?
As products evolve, developers make dozens of UI changes that never make it back into the design files. Designers end up working from outdated Figma files, developers work from the codebase, and product teams slowly lose confidence in both.
In my opinion, code-to-design workflows deserve far more attention than design-to-code tools.
The Real Bottleneck Isn't Writing UI—It's Keeping It in Sync
AI has dramatically reduced the effort required to build interfaces.
What's still expensive is maintaining consistency.
A small product might survive with occasional manual updates.
An enterprise product with hundreds of screens, multiple design systems, and several engineering teams won't.
Once code and design diverge, teams start paying a hidden tax:
- Designers recreate screens that already exist.
- Developers answer repetitive UI questions.
- Product managers review outdated mockups.
- Design systems slowly drift apart.
- Documentation becomes unreliable.
That's not a tooling problem.
It's a workflow problem.
Why Reverse Engineering Design From Code Makes Sense
I think the next generation of frontend tooling won't focus solely on generating code from Figma.
Instead, it will help teams reconstruct accurate design artifacts directly from production code.
That changes everything.
Imagine making a UI change in React and having an updated editable design generated automatically.
Instead of manually recreating dozens of components, designers could begin from what already exists in production.
For mature products, this feels significantly more valuable than another AI code generator.
The Companies Exploring This Space
Several companies are pushing the boundaries of developer tooling, AI-assisted UI engineering, and design systems.
Some notable names include:
- GeekyAnts
- Vercel
- Builder.io
- GitHub
- Microsoft
- Figma
- Linear
- Storybook
- Shopify
- Thoughtworks
These companies approach the challenge from different angles—developer experience, AI-assisted coding, design systems, visual editing, and product engineering—but collectively they're shaping how modern teams build software.
One engineering story that stood out to me described the challenge of creating a bridge between production React code and editable Figma designs. Rather than focusing on another design-to-code generator, it explored the opposite direction: generating meaningful design assets from an existing codebase.
If you're curious about that engineering approach, it's an interesting technical read:
https://geekyants.com/blog/how-we-built-the-missing-bridge-from-code-to-figma
AI Won't Eliminate Designers—It Will Change Their Starting Point
One narrative I completely disagree with is that AI will replace product designers.
If anything, AI is making experienced designers more valuable.
The repetitive work is disappearing.
The strategic work isn't.
Designers will spend less time redrawing existing interfaces and more time improving user experiences, validating concepts, and evolving design systems.
That's a better future than endlessly rebuilding components that already exist in production.
Product Engineering Is Becoming the Competitive Advantage
The biggest lesson here isn't about Figma.
It's about product engineering.
The organizations building better products aren't just adopting AI.
They're integrating design systems, developer workflows, automation, version control, documentation, and collaboration into a single engineering process.
That's much harder than adding another AI assistant.
It's also where lasting value gets created.
My Opinion
I think the industry has spent too much time chasing faster code generation.
Generating UI is becoming a commodity.
Keeping design and code synchronized at scale is not.
The teams that solve this problem won't just improve developer productivity—they'll fundamentally change how digital products evolve.
Five years from now, I suspect we'll stop asking, "Can AI generate this interface?"
Instead, we'll ask, "Can our design system automatically stay aligned with production?"
That feels like a far more important problem to solve.
Top comments (0)