Despite an explosion of design tools in the past few years aiming to bridge the gap between design and engineering, the worlds of a designer and an engineer remain acutely distinct. What designers produce bears no technological resemblance to the output of engineers,and therefore what customers are ultimately exposed to. This chasm between a designer's final output (static screens) and an engineer's final output (code) has damaging implications to delivering the best possible user experiences. The tools that we have at our disposal as designers do a great job of allowing us to ideate, but when it comes time to implement solutions our design and engineering teams are speaking different languages.

The problem

Today, the norm for all too many designers is to spend countless hours focusing on the precision of their designs, producing pixel-perfect images, and, on that rare occasion, building superficial prototypes. This process involves creating tons of throwaway work that doesn’t test the user experience but an approximation of it. Much of this work happens in a virtual customer vacuum with little to no experimentation, and with user validation that's hobbled by unrealistic approximations of the actual app, devoid of user context or real-world usage. The illusion quickly falls apart and leads to suboptimal test results, but we go ahead and ship anyway.

The advent of design systems allowed us to paint using broader strokes as we have a library of components that control the precision. We can focus on solving actual problems rather than focusing on individual pixels. The more advanced teams amongst us may even build prototypes using reusable design system components, greatly reducing the cost of implementing and showcasing their ideas. The core problem, however, remains, as the prototype is still a mere replica of the actual product, still devoid of user context and real-world usage, still just an illusion.

Our mission is to enable designers to experiment with and validate their ideas not through an illusion of a product, but through the real product itself. Iteratively absolves designers from building their own, silo’d replica to prototype their ideas. Instead, designers use real components to augment the real product with new experiences. Their customers' accounts, data, and full context are all present, because the prototype is just a modified version of the real app. The following trends helped inform our position on how design tools will evolve over time.

Future apps will be built exclusively using component-based frameworks.
Backed by comprehensive design systems based on atomic design principles.

The gap between designers and developers is converging.
Future designers will become more full stack, proficient in basic frontend development, and able to deliver real code artifacts to engineering to streamline development flows.

Design will own and control shipping product as an equal with dev.
Experimentation, validation, and deployment of design work to production will be the design team’s responsibility.

Design teams will fully embrace iteration and continuous improvement.
In agile teams shipping is not the definition of done, you might need to iterate multiple times before you are happy with the result.

Our approach

We have broken out how we want to deliver our vision into three phases.

1. Composition
Designers can change the style, copy and layout of components all while using real data. It's simple, intuitive, and works flawlessly on top of your production app.

2. Interactivity
Designers can create new flows and interactions via a set of building blocks, or import components from other tools, all without needing to write any code.

3. Experimentation
Designers can experiment and validate in production. We want to lower the barrier for designers to make data informed decisions to improve their products.

We are super excited to be launching our preview release to the design community for phase one. We are slowly rolling out invites and you can request early access to be a part of the preview.

Got feedback?