AI Engineer

The Design-Code Roundtrip That Isn't — Jonathan Gordon, ReWeaver AI

1940 summary words 9 min summary Watch video

Start with the signal

9 min read

Summary

At-a-Glance

  • Verdict: Watch fully
  • Core thesis: AI has not solved a lossless, bidirectional design-code roundtrip; because LLM-generated changes are probabilistic and accumulate drift, teams need deterministic reconciliation and human-controlled guardrails around AI generation.
  • Why it matters: As AI increasingly generates UI and application code, design fidelity, accessibility, security, provenance, and production readiness can silently diverge across iterations even when individual demos appear magical.
  • Best use: Use this as a product and architecture lens for governing AI-generated frontend code: treat design-code synchronization as a continuous verification and remediation problem, not a one-time export/import integration.

Executive Summary

Jonathan Gordon argues that the industry’s apparent design-to-code and code-to-design breakthroughs are being overstated. His definition of a real roundtrip is demanding: bidirectional changes must preserve fidelity, retain all relevant surfaces and bindings, and carry persistent provenance so a designer can identify the source code behind a visual object. Across five tool configurations, he says he found lossy behavior rather than that standard—such as lost bindings or changes that survived on the design side but not in code.

His broader point is that LLMs make application generation fast but do not make it deterministic. Gordon’s own vibe-coding experience exposed this when he noticed an AI-generated innerHTML implementation, a potential injection risk, amid generated code he had initially not been reviewing. He frames these errors not as a reason to reject AI, but as evidence that teams need to inspect, constrain, and reconcile its outputs.

ReWeaver AI is presented as that control layer: it scans code and designs for drift across quality dimensions, identifies issues such as an absent ARIA live region, and can propose or apply an explicitly user-approved repair. The proposed operating model is not agent autonomy with humans merely supervising; it is human control over code, design, and cost, while deterministic guardrails catch defects before merge.

The talk is most useful for the governance model rather than for a validated claim that ReWeaver itself has solved the problem. The speaker reports an internal 12-iteration experiment in which pure AI began at roughly 30% fidelity/quality and degraded, while deterministic guardrails improved outcomes but still could not reach 100% because he assigns the final 10% to human judgment. The methodology and exact metrics are not disclosed, so regard the figures as directional product framing rather than independent benchmark evidence.

Key Takeaways

  • Claim: A genuine design-code roundtrip requires more than generating a Figma canvas or exporting implementation code: it must be bidirectional, lossless, and provenance-preserving. | Evidence: Gordon defines the target state as a full design-engineering loop with no fidelity loss, all surfaces preserved, and traceability from a design artifact such as a button back to the code that created it. | Implication: Evaluate design-code tools by whether edits preserve bindings, semantics, source relationships, and implementation behavior in both directions—not by whether they can produce an impressive one-way demo. | Caveat: This is the speaker’s stringent product definition, rather than an industry-standard definition; many tools marketed as roundtrip solutions solve a narrower conversion or synchronization problem.
  • Claim: Current claims that the design-code roundtrip is solved do not hold up under iterative, bidirectional testing. | Evidence: After seeing Anthropic/Figma-style code-to-Figma demonstrations and subsequent Figma Config announcements, Gordon tested five tool setups for code-design-code workflows and reports lossy outcomes: bindings were lost, and design changes could persist while corresponding code changes did not. | Implication: Do not architect workflows around a presumed canonical shared state between design canvas and production code until the specific tools, data model, and edge cases are validated on your own component library. | Caveat: He provides neither the names/configurations of all five setups nor reproducible test cases, so this is informed practitioner evidence rather than a published comparative evaluation.
  • Claim: AI-generated UI code creates defects that can be hidden by successful visual output, including security and accessibility failures. | Evidence: While vibe coding, Gordon caught an AI-generated innerHTML statement that he regarded as an injection vulnerability. In his ReWeaver demo, the system detected a missing ARIA live region, meaning a blind screen-reader user would not receive an announcement about an element. | Implication: Visual parity and functioning click paths are insufficient AI-code acceptance criteria; security and accessibility checks need to be enforced as first-class gates in the generation-to-merge pipeline. | Caveat: The transcript does not establish that every use of innerHTML is exploitable or that the shown accessibility defect is representative of all models and prompting practices.
  • Claim: Drift is inherent when probabilistic LLM generation is inserted into formerly deterministic development workflows, and accumulated drift becomes a new form of technical debt. | Evidence: Gordon contrasts deterministic tools—where compiling the same code yields the same AST/result—with LLM systems that may produce varying outputs. He distinguishes immediate generation-time drift from drift that compounds over roughly the next six months as the codebase evolves. | Implication: AI coding systems need ongoing reconciliation rather than only initial generation QA: monitor deviations across iterations, branches, component changes, and design-system evolution. | Caveat: The “new tech debt” framing is conceptual; no longitudinal measurement of drift accumulation is provided.
  • Claim: Deterministic guardrails can materially improve AI-led UI development, but they cannot eliminate the need for human judgment. | Evidence: In a 12-iteration experiment on a UI codebase, Gordon says a pure-LLM approach began around 30% quality/fidelity and degraded; applying deterministic checks that found and fixed issues improved the result. He says 100% cannot be reached because the final 10% requires human decisions. | Implication: Build an operational model with deterministic automated checks for objective constraints and named human reviewers for subjective design intent, tradeoffs, and exceptions. | Caveat: The experiment’s quality definition, baseline, scoring procedure, and final result are not supplied, and the claim comes from ReWeaver’s founder.
  • Claim: ReWeaver’s proposed model is a local, human-authorized drift-control layer rather than an autonomous code-writing agent. | Evidence: The product scans code and design across dimensions including design quality, code quality, performance, design tokens, accessibility, and AI code-generation governance. It can surface a repair and write it only after a user chooses “apply”; the user can undo or ignore it. Gordon says its core operation uses a local LLM with zero additional token cost, while external model connections remain optional. | Implication: The relevant category is an AI-code control plane/quality gate: assess it on determinism, auditability, rule coverage, local deployment characteristics, and CI/pre-merge integration—not simply generation quality. | Caveat: The talk does not explain the local model, coverage limits, supported frameworks/design sources, evaluation results, or how “zero extra token costs” is calculated.
  • Claim: The desired end-state is “human in control,” not agents in control with humans merely in the loop. | Evidence: Gordon characterizes current workflows as AI-locked loops across agents, chatbots, and tools, with token costs and agents effectively directing the flow. His alternative is explicit human control over cost, code, and design, supported by guardrails that either apply known fixes or flag unresolved problems for human resolution. | Implication: For production agent workflows, make authority boundaries explicit: agents may propose and execute bounded repairs, but humans should retain approval, rollback, budget, and exception-handling rights.

Detailed Brief

ReWeaver product framing and proposed quality model

  • Claims: ReWeaver is positioned as a closed-loop system that detects drift before code merges rather than as another design generator or code generator.; The product’s stated foundation is nine dimensions of deterministic guardrails for software quality and production readiness.; Design-system consistency is a central target: components, tokens, variables, and styles should remain aligned between the design system and the codebase.
  • Evidence: The demo harness placed AI-generated code beside a design artifact from sources such as Figma or Sketch, then used a “show drift” action to produce issues across design quality, code quality, performance, and design-token dimensions.; Gordon explicitly names design consistency, accessibility, and AI code-generation governance as top-level dimensions.; He describes an accept-or-refuse posture: known remediations can be applied, while unresolved findings are surfaced for the user to fix.
  • Caveats: The remaining six of the claimed nine dimensions are not identified in the transcript.; No integration details are given for pull requests, CI, Figma APIs, source-control provenance, policy configuration, or enterprise security.
  • Implications: The strongest product requirement is a canonical issue model linking design and code findings, remediations, approvals, and rollback history.; A meaningful evaluation should test whether findings remain stable and useful as component libraries, token sets, and model-generated patches evolve.

Go-to-market status and validation posture

  • Claims: ReWeaver was presented as a new company and the shown functionality as its first public code demonstration.; The company is seeking beta participants and external sanity checks rather than claiming mature general availability.
  • Evidence: Gordon directs viewers to reweaver.ai/playground to scan their AI-generated code.; The playground includes a challenge to generate code below a 0.30 PDR, defined as production drift ratio, with beta access offered as a reward.; He says the company hoped to expand the beta in mid-July.
  • Caveats: The transcript supplies no definition of the PDR calculation beyond its name, so it cannot yet serve as an operational benchmark.; The proposed mid-July timing is a stated plan, not proof of current availability or product readiness.
  • Implications: If evaluating the company, request the PDR rubric, false-positive/false-negative rates, supported stacks, and a blinded comparison against existing linting, accessibility, visual-regression, and design-token tooling.

Notable Concepts & Terms

  • Design-code roundtrip: The desired ability to move changes from design to implementation and back again without losing fidelity, semantics, bindings, or traceability.
  • Persistent provenance: A durable link between visual design objects and their originating or corresponding code, required for trustworthy bidirectional editing.
  • Drift: The mismatch between design intent, design artifacts, generated code, and production behavior; the talk treats both immediate and cumulative drift as the core failure mode.
  • Deterministic guardrails: Rule-based or reliably repeatable checks and remediation workflows placed around probabilistic AI generation to identify, constrain, and reconcile defects.
  • Production Drift Ratio (PDR): ReWeaver’s cited score for production drift; the speaker uses 0.30 as a challenge threshold but does not disclose the measurement formula.
  • AI code-generation governance: Controls over rapidly generated code, including visibility, approval, remediation, and prevention of unsafe or noncompliant output.
  • ARIA live region: An accessibility mechanism that causes dynamic updates to be announced by screen readers; its absence was the concrete accessibility defect shown in the demo.
  • Human in control: Gordon’s preferred control model: AI assists and may execute approved changes, but people retain authority over design, code, budgets, and final judgment.

Operator Notes / Why Ken Should Care

  • Add deterministic pre-merge checks for AI-authored frontend changes across security, accessibility, design-token use, performance, and visual/design-system conformance; do not rely on agent self-review.
  • Require every generated UI change to retain a traceable relationship among prompt/task, source files, component identifiers, design-system tokens, reviewer approval, and rollback path.
  • Create a representative bidirectional test suite before adopting any design-code synchronization vendor: include state bindings, responsive behavior, dynamic content, semantics, accessibility, token overrides, and subsequent edits on both sides.
  • Separate objectively enforceable rules from subjective review: automate the former, and explicitly assign human ownership for the latter rather than optimizing for nominal full autonomy.
  • If considering ReWeaver, treat it as an early-stage governance tool and request an evaluation package that defines PDR, reveals supported stacks and design inputs, and measures detection quality against incumbent checks.

Source/Metadata

  • Title: The Design-Code Roundtrip That Isn't — Jonathan Gordon, ReWeaver AI
  • Transcript words: 5842
  • Duration seconds: 1116
  • Timestamp note: No timestamps or chapters were present. The transcript contains a near-complete repeated presentation segment.
Full transcript 2951 words · 26 min read
0:12

[SPEAKER_00] Hello everyone. I'm Jonathan Gordon. I'm a founder of ReWeaver AI, a new company on the scene. I want to share one thing with all of you that was really fascinating. So I plugged in my laptop and I realized I had to mirror, so I no longer had my speaker notes. So I went into Claude and I said, can you extract my speaker notes from my slide deck, please? And I had my speaker notes now. I love AI. I was talking to Claude. Now who knows if it got it right. Whatever. So I also realized that my title slide buried the lead. I shouldn't have put it up. But nonetheless, let's play with this. So my name is Jonathan. I'm here to talk to you about the design code round trip that isn't. And I guess probably the best thing to do first is to explain what I think a design code round trip should be. A design code round trip is a full loop between design and engineering in both directions without any loss of fidelity and with a persistent provenance. It knows exactly where everything came from. That perfect dream world that we live in of doing a design, where there is no drift between the gaps of design and code. Today's tools, design is amazing. It's incredible. It's magic. I asked for something. I get it. It's clickable. It's interactive. It's amazing to me. But nobody really looks at the code anymore. And so I want to go there. I want to go into that space. Of course, I have to get my mouse to the right location. There we go. A little bit about me. Past 30 plus years, I've been building and designing coding tools, developer tools, IDEs at these companies. So I've spent a lot of time as a designer with design and engineering teams, trying to understand how do we do that handoff well. How do we hand off from design to code? How do we get what we wanted to be delivered to the customer? It was never a perfect science. We never got it. We never found that magic sauce that just made everything come together, where intent matched the outcome. But I developed techniques. I negotiated with engineers. I brought them out for drinks. I made them my friends. I got things delivered to customers. But the loop was never closed. And it's because our outcomes diverged. Engineering had one set of requirements, technical constraints, design had a vision for the future, a new rebranding, whatever. So this has existed for decades. And then along comes AI and LLM and prompting ourselves into a fully running application. Now we have one intelligence that understands design intent. And the same intelligence can write code. So I thought to myself, I think we might be able to close this loop. At the speed of inference, we could close this loop. And so I was curious. I'm curious by nature. So I went all in. That's my GitHub before Vibe coding happened. On the left. On your whatever. Then after. So everybody probably gets a sense of what my life was like from April 2025. And if you want to scroll till today, it's even more so. I got this email from Cursor one day that said I was in the top 0.1% of usage of Cursor. And I thought to myself, I need to spend more time outside. Then there was a bill. But at the time it was the $20 deal and I monitored. But every now and again I'd pay for a little bit more. Get another hit. And this was my life, Vibe coding. From that point in April until today. I'm trying to figure out can I go from design to code? Can I go from code to design? Can I build a tool to go from design to code and code to design? A full round trip without any loss of fidelity. That pixel perfect dream that we have. I remember vividly one day I was hammering away at the keyboard. Just vibing my way. I was really feeling the vibe. And this wall of text was coming by and I was completely ignoring it. And code was being written. Just watching that come by. And I remember seeing a statement that was an inner HTML statement. And I remember from way back when that inner HTML was a security vulnerability that people can actually inject into inner HTML. And I stopped it. And I said, wait a minute. To my LLM. Wait a minute. What did you just do? And it explained to me what it did. And it was very proud of itself. And I said, revert that. Do this instead. And I got into this mode, maybe I need to steer this thing a little bit better. Maybe I can't just go blindly in. Maybe I need to look at the code now. And I've looked at a lot of code in my life. So I went ahead and went in and looked at the code. And I clicked two ahead. And I found issues. And so I went a little bit deeper when the industry started to tell me that they had solved the round trip. That you could go a true round trip workflow. You could round trip between code and Canvas. I think folks in the room might remember back in February, no slam on Anthropic or Figma. There was this demo that showed going from cloud code into Figma. And it was magic. It was incredible. I couldn't believe you could build a Figma artboard from a prompt in cloud code. And then I had to go deeper. And I had to look deeper. In the same way that I looked at vibe coding. Is this real? Is the hype real? So I went deeper. And then more announcements were made. All the way up until last week. When Figma config announced that code is now material. Does that mean there is no even handoff that exists anymore? So I'm monitoring. Trying to keep up. Things are happening at warp speed. But they said the round trip was solved. And I started messing around and realized it wasn't. And so I want to share with all of you a harness that I built. Localhost. Where are you, Localhost? Come back to me, Localhost. Okay. I think we're okay. I created this harness. And what this harness is, is on I'm going to say left. I hope everybody. Is that your left? It is your left. Okay, good. On your left is code that was generated by AI. This is all real, what you're seeing here. Generated by AI. And on your right is a design. Be it a canvas that I created in Figma. Be it something I created in Sketch. It's not really relevant what the sources are here. But the reality is I'm trying to illustrate a round trip. And a round trip, starts with code or starts with design. And it has a prompt associated with it. So some LLM I call off and I say, in this instance, I want to take this form and I want to build a design system from it. So there are tools that do this. That can extract code and build design systems from graphical canvases. And so I can do that. And it updated the code and created some styles. And it also actually created a design system that works in runtime here. So this is a real app that got built that is also living in Figma. So there's a link up here. I won't go there, but trust me. So we can say stable. If I click that link, it would go to Figma and show me the full blown design system that was built. And a design system, for those that don't know, is composed of components and tokens and variables and styles that all are used as a basis for building software from. So code and design together, really work well when there's a design system and there's a code base that understands it. Now, move back and forth, you throw something over here and you say, okay, I want to build an orange button. And I've added a company field and an orange button. The code is updated. The design is updated. This is awesome. Could I go back? Maybe. But I have a button up here called show drift. So show drift is ReWeaver AI working right now. And this is real ReWeaver code for the first time introduced to the public ever. So I'm going to go back here. And if I click show drift, I'll see a list of issues that got generated from both the code and the design at the same time. There are across several different dimensions that you can see here. Design quality, code quality, performance, design tokens, et cetera. One of the ones of note that I find really important from my perspective is that at Microsoft, I worked on accessibility. And I learned a lot about what it means to build an accessible software system. And I want to be honest with all of you, I was very frustrated when I first saw LLMs come out and they generated code that was inaccessible. Period. Out of the box. I thought, what, models weren't trained on accessibility? And I was reminded 20 years ago when engineers needed to be trained on accessibility. So here we are again now training LLMs instead of engineers on accessibility. So found issues. Here's an issue where has no ARIA live region. So it won't be announced by screen reader. A blind user using this won't get an announcement about this element. So ReWeaver found that. And ReWeaver says it can fix it. And ReWeaver fixed it. Now the red went away, but there's also a blue issue here as well. So ReWeaver stacks up issues and scans the code and scans the design. And produces guardrails, but also a way to fix the code and make it better. So I did that across multiple dimensions, with the intention of seeing if anybody had solved the round trip problem. And it didn't go well. I never got really the full round trip. I really tried, hopefully this slide tells you, I tried five different tool setups. Trying to do code design code round trip, both directions, bi-directional. Lots of lossy issues. Bindings were lost. Design change survived, but code didn't. I'm not going to say we won't get there. But even if we do get there, and we're able to do this, I wonder if we'll get fully there. And maybe we need tools like ReWeaver. We do need tools like ReWeaver to help us understand the drift. So that whole experience for me really highlighted something from my past. I had built a lot of software development tools. Designed and built software development tools. And developer tools in their nature are deterministic. You write code, you compile it, you get an AST. Every time you run that code, you'll get the same result. When you put AI in the middle of that, or the front of that, or the end of that, you're not going to necessarily get the same outcomes. Now, there are tools that'll help you understand, ReWeaver being one of them, that there's a mismatch. There's drift there. And we need to be aware of drift. Drift lurks in the dark. You need to look at the code. You need to find the drift. You need to fix the drift. And you do that with deterministic guardrails around the AI. The AI is still there. So I ran another experiment. 12 iterations on a code base with complex enough UI to it. And I did one where it was just pure AI led. Just LLM all the way. And it degraded a little bit. But it started at 30% quality. 30% fidelity. 30% true pixel perfection. And then I put it on top of deterministic guardrails. Where we found the issues. We fixed the issues. You can't get to 100. Because that 10% is human judgment. Human decision making. So the human is still there in this equation. So what is it today? Today, I would call it we're locked into AI. And that's okay. We'll go there. We'll embrace that. But we're locked into AI for design to code. We're locked into AI for code to design. Looping. Chatbots. What we call span the chain workflows. Where you're jumping across tools. And there's always token costs to be aware of, of course. So in this world, the agents are in control and the humans in the loop. I'd like to pose something else. Before I do, there are three blind spots we need to be aware of. One is the model itself. It's going to. You can ask the questions. It'll give you answers. But it's non-deterministic. It's probabilistic. There will be drift in the moment. When you're writing code, drift will surface. But drift over time is the pain that you'll be experiencing for the next six months. Because drift over time is the new tech debt. And it's going to pile itself gloriously over your code base. So here's where we think it isn't. Meaning what it could be. What it should be. Fully bi-directional. Edit both ways. Lossless. All surfaces preserved. So if you go from code to design and design to code, nothing's breaking weirdly for you. Provenance is carried. Where did this start from? What line of code wrote this button? I see this button in Figma. I want to change it. I need to change that code. Or somebody needs to change that code. We have to control the drift. It's deterministic reconciliation at its core. So with deterministic guardrails, and I'm happy to talk after if folks are interested in what I mean by that. Accept or refuse. So if they know there's a fix, they will fix it. If they don't know there's a fix, they will tell you there's an issue. But you need to fix it. And with ReWeaver, there's zero extra token costs. So we're fully local LLM. But if you want to open up Claude or whatever and connect to us, you can. But at its core, and our core principle is the human is in control. Always. In control of cost. In control of code. In control of design. Because that's what we've been doing for decades. We've been in control. We don't need to lose control. And I'm not saying loop isn't good. But human in control is, I think, a little more aspirational. Because at the end of the day, what you need is actually what you get. I call it What You Need Is What You Get. So what are we building? At its core, what we're building are nine dimensions of deterministic guardrails. Inside of this is a lot of stuff. But these are our top level software quality, software production readiness dimensions. Design consistency being core, of course. And when you have a design system and the code isn't consistent with it and vice versa, we need to fix that. So there's a lot of design consistency work that's going into the foundation. Accessibility is its own dimension. Maybe selfish of me. But I think it's core. AI code generation governance is another really critical piece because the code is just flying through the system. And we need to govern that code. Now we're not going to change the code. ReWeaver actually doesn't write code. You write code. ReWeaver will do what you want it to do. So if you say apply the fix, it'll write the code for you. You can see the code being written. You can say never mind undo. You can ignore it. So at the end of the day, catch what drifts in a closed loop before anything merges. That's the goal. You can try it out with your own code today, right now. You can go to reweaver AI slash playground. And we built a similar harness to what I built there. Where you can put your AI generated code on the left. You can scan it and get your results for that code. There's also a fun little challenge on that page. If you can get AI to generate code that gives you a score lower than .30 PDR, which is production drift ratio, we'll get you a frontline seat on the beta. But you'll also get yourself showcased at the bottom on the crawl. So give it a shot. Take a look. Meanwhile, I'm looking for people to join our beta. We're going to basically blast out mid-July, hopefully. So we'd love for you to join if you're interested to make the product better, to sanity check us. Basically, that's it. And you can also reach me online or outside. Happy to talk more. Thank you.

0:18

new on the scene, let's say. I want to share one thing with all of you that was really fascinating. So I plugged in my laptop and I realized I had to mirror, so I no longer had my speaker notes. So I went into Claude and I said, can you extract my speaker notes from my slide deck, please? And I had my speaker notes now. I love AI. The suspense was killing me. I was talking to Claude. Now who knows if it got it right. I don't know. Whatever. So I also realized that my title slide buried the lead. I shouldn't have put it up. But nonetheless, let's play with this. So yeah, my name is Jonathan.

0:58

I'm here to talk to you about the design code round trip that isn't. And I guess probably the best thing to do first is to explain what I think a design code round trip should be. A design code round trip is a full loop between design and engineering in both directions without any loss of fidelity and with a persistent provenance. So it knows exactly where everything came from. You know, that perfect dream world that we live in in a way of doing a design, where there is no drift in between the gaps of design and code. Today's tools, design is amazing. It's incredible. It's magic. It's, I asked for something. I get it.

1:48

It's clickable. It's interactive. It's amazing to me. But nobody really looks at the code anymore, it seems. And so I kind of want to go there. I want to go into that space. Whoops. Of course, I have to get my mouse to the right location. There we go. A little bit about me. Past 30 plus years, I've been building and designing coding tools, developer tools, IDEs at these companies. So I've spent a lot of time with, as a designer, I've spent a lot of time with design and engineering teams, trying to understand how do we do that handoff well. How do we hand off from design to code? How do we get what we wanted to be delivered to the customer? It was never a perfect science.

2:37

We never got it. We never found that magic sauce that just made everything come together, where intent matched the outcome. But I developed techniques. I negotiated with engineers. I brought them out for drinks. I made them my friends. I got things delivered to customers. But the loop was never closed. And it's because our outcomes diverged. Engineering had one set of requirements, technical constraints, design had a vision for the future, a new rebranding, whatever. So this has existed, you know, dare I say, for decades.

3:16

And then along comes AI. And LLM and prompting ourselves into a fully running application. In a sense, now we have one intelligence that understands design intent. And the same intelligence can write code. So I thought to myself, oh my god, I think we might be able to close this loop. At the speed of inference, we could close this loop. And so I was curious. I'm curious by nature. So I went all in. That's my GitHub before Vibe coding happened. On the left. On my left. On your whatever. Then after. So I think everybody probably gets a sense of what my life was like from April 2025. And if you want to scroll till today, it's even more so.

4:12

I got this email from Cursor one day that said I was in the top 0.1% of usage of Cursor. And I thought to myself, I need to spend more time outside.

4:28

Then there was a bill. But at the time it was the $20 deal and I kind of, you know, monitored. But every now and again I'd pay for a little bit more. Get another hit. And this was my life, Vibe coding. From that point in April until today. I'm trying to figure out can I go from design to code? Can I go from code to design? Can I build a tool to go from design to code and code to design? A full round trip without any loss of fidelity. That pixel perfect dream that we have. I remember vividly one day I was, you know, just hammering away at the keyboard. Just vibing my way. I was really feeling the vibe. And this wall of text was coming by and I was completely ignoring it.

5:19

And code was being written. Just watching that come by. And I remember seeing a statement that was an inner HTML statement. And I remember from way back when that inner HTML was a security vulnerability that people can actually inject into inner HTML. And I stopped it. And I said, wait a minute, wait a minute. To my LLM. Wait a minute. What did you just do? And it explained to me what it did. And it was very proud of itself. And I said, revert that. Do this instead. Blah, blah. And I got into this mode of like, oh, maybe I need to steer this thing a little bit better. Maybe I can't just go blindly in. Maybe I need to look at the code now.

5:59

And I've looked at a lot of code in my life. So I went ahead and went in and looked at the code. And I, whoops, I'm sorry. Clicked two ahead. And I found, I found issues. And so I went a little bit deeper when the industry started to tell me that they had solved the round trip. That you could go a true round trip workflow. You could round trip between code and Canvas. I think folks in the room might remember back in February, no slam on Anthropic or Figma. There was this demo that showed going from cloud code into Figma. And it was magic. It was incredible.

6:39

I couldn't believe you could build a Figma artboard from a prompt in cloud code. And then I had to go deeper. And I had to look deeper. In the same way that I looked at vibe coding. Like, is this real? Is the hype real? So I went deeper. And then more announcements were made. All the way up until last week. When Figma config announced that code is now material. Does that mean there is no even handoff that exists anymore? So I'm monitoring. Trying to keep up. Things are happening at warp speed. But they said the round trip was solved. And I started messing around and realized it wasn't.

7:17

And so I want to share with all of you a harness that I built. Whoops. Oh, wait a minute. Localhost. Where are you, Localhost? Come back to me, Localhost. Okay. I don't know what just happened there. And now I'm afraid to restart this. Okay. I think we're okay. I created this harness. And what this harness is, is on... I'm going to say left. I hope everybody... Is that your left? It is your left. Okay, good. On your left is code that was generated by AI. This is all real, what you're seeing here. Generated by AI. And on your right is a design. Be it a canvas that I created in Figma. Be it something I created in Sketch.

8:05

It's not really relevant what the sources are here. But the reality is I'm trying to illustrate a round trip. And so a round trip, you know, starts with code or starts with design. And it has a prompt associated with it. So some LLM I call off and I say, in this instance, I want to take this form and I want to build a design system from it. So there are tools that do this. That can extract code and build design systems from graphical canvases. And so I can do that. And it updated the code and created some styles. And it also actually created a design system that works in runtime here.

8:44

So this is like a real app that got built that is also living in Figma. So there's a link up here. I won't go there, but trust me. So we can say stable. If I click that link, it would go to Figma and show me the full blown design system that was built. And a design system, for those that don't know, is composed of components and tokens and variables and styles that all are used as a basis for building software from. So code and design together, you know, really work well when there's a design system and there's a code base that understands it.

9:16

Now, move back and forth, you throw something over here and you say, okay, I want to build an orange button. And I've added a company field and an orange button. The code is updated. The design is updated. This is awesome. Could I go back? Maybe. But I have a button up here called show drift. So show drift is reweaver AI working right now. And this is real reweaver code for the first time introduced to the public ever. So I'm going to go back here. And if I click show drift, I'll see a list of issues that got generated from both the code and the design at the same time.

9:54

There are across several different dimensions that you can see here. Design quality, code quality, performance, design tokens, et cetera. One of the ones of note that I find really important from my perspective is that at Microsoft, I worked on accessibility. And I learned a lot about what it means to build an accessible software system. And I want to be honest with all of you, I was very frustrated when I first saw LLMs come out and they generated code that was inaccessible. Period. Out of the box. I thought, what, models weren't trained on accessibility? And I was reminded 20 years ago when, you know, engineers needed to be trained on accessibility.

10:33

So here we are again now training LLMs instead of engineers on accessibility. So found issues. Here's an issue where has no ARIA live region. So it won't be announced by screen reader. A blind user using this won't get an announcement about this element. So reweaver found that. And reweaver says it can fix it. And reweaver fixed it. Now the red went away, but there's also a blue issue here as well. So reweaver stacks up issues and, you know, basically scans the code and scans the design. And produces guardrails to a sense, but also a way to fix the code and make it better.

11:15

So I did that across multiple dimensions, you know, with the intention of seeing if anybody had solved the drown, the round trip problem. And it didn't go well. I never got really the full round trip. I really tried, hopefully this slide tells you, I tried five different tool setups. Trying to do code design code round trip, both directions, bi-directional. Lots of lossy issues. You know, bindings were lost. Design change survived, but code didn't. I'm not gonna say we're not gonna get there. But even if we do get there, and we're able to do this, I wonder if we'll get fully there.

11:59

And maybe we need tools like reweaver. I shouldn't say maybe. We do need tools like reweaver to help us understand the drift. So that whole experience for me really highlighted something from my past. I had built a lot of software development tools. Designed and built software development tools. And developer tools in their nature are deterministic. You write code, you compile it, you get an AST. Every time you run that code, you'll get the same result. When you put AI in the middle of that, or the front of that, or the end of that, you're not gonna necessarily get the same outcomes. Now, there are tools that'll help you understand,

12:41

reweaver being one of them, that there's a mismatch. There's drift there. And we need to be aware of drift. Drift lurks in the dark. You need to look at the code. You need to find the drift. You need to fix the drift. And you do that with deterministic guardrails around the AI. The AI is still there. So I ran another experiment. 12 iterations on a code base with complex enough UI to it. And I did one where it was just pure AI led. Just LLM all the way. And it degraded a little bit. But it started at 30% quality. 30% fidelity. 30% true pixel perfection. And then I put it on top of deterministic guardrails. Where we found the issues. We fixed the issues.

13:26

You can't get to 100. Because that 10% is human judgment. Human decision making. So the human is still there in this equation. So what is it today? Today, I would call it we're locked into AI. And that's okay. We'll go there. We'll embrace that. But we're locked into AI for design to code. We're locked into AI for code to design. Looping. Chatbots. What we call span the chain workflows. Where you're jumping across tools. And there's always token costs to be aware of, of course. So in this world, the agents are in control and the humans in the loop. I'd like to pose something else. Before I do, there are three blind spots we need to be aware of.

14:11

One is the model itself. It's gonna... You can ask the questions. It'll give you answers. But it's non-deterministic. It's probabilistic. There will be drift in the moment. When you're writing code, drift will surface. But drift over time is the pain that you'll be experiencing for the next six months. Because drift over time is the new tech debt. And it's gonna pile itself gloriously over your code base.

14:42

So here's where we think it isn't. Meaning what it could be. What it should be. Fully bi-directional. Edit both ways. Lossless. All surfaces preserved. So if you go from code to design and design to code, nothing's breaking weirdly for you. Provenance is carried. Where did this start from? What line of code wrote this button? I see this button in Figma. I want to change it. I need to change that code. Or somebody needs to change that code. We have to control the drift. It's deterministic reconciliation at its core. So with deterministic guardrails, and I'm happy to talk after if folks are interested in what I mean by that. Accept or refuse.

15:28

So if they know there's a fix, they will fix it. If they don't know there's a fix, they will tell you there's an issue. But you need to fix it. And with Ruby Weaver, there's zero extra token costs. So we're fully local LLM. But if you want to open up Claude or whatever and connect to us, you can. But at its core, and our core principle is the human is in control. Always. In control of cost. In control of code. In control of design. Because that's what we've been doing for decades. We've been in control. We don't need to lose control. And I'm not saying loop isn't good.

16:05

But human in control is, I think, a little more aspirational. Because at the end of the day, what you need is actually what you get. I call it Winnie Wig. Can I use that? Winnie Wig? So what are we building? At its core, what we're building are nine dimensions of deterministic guardrails. Inside of this is a lot of stuff. But these are our top level software quality, software production readiness dimensions. Design consistency being core, of course. And when you have a design system and the code isn't consistent with it and vice versa, we need to fix that. So there's a lot of design consistency work that's going into the foundation. Accessibility is its own dimension.

16:53

Maybe selfish of me. But I think it's core. AI code generation too. Or AI code, sorry, governance. AI code generation governance is another really critical piece because the code is just flying through the system. And we need to govern that code. Now we're not going to change the code. Reweaver actually doesn't write code. You write code. Reweaver will do what you want it to do. So if you say apply the fix, it'll write the code for you. You can see the code being written. You can say never mind undo. You can ignore it. So at the end of the day, catch what drifts in a closed loop before anything merges. That's the goal.

17:32

You can try it out with your own code today, right now. You can go to reweaver AI slash playground. And we built kind of a similar harness to what I built there. Where you can put your AI generated code on the left, on the left. You can scan it and get your results for that code. There's also a fun little challenge on that page. If you can get AI to generate code that gives you a score lower than .30 PDR, which is production drift ratio, we'll get you a frontline seat on the beta. But you'll also get yourself showcased at the bottom on the crawl. So give it a shot. Take a look.

18:12

Meanwhile, I'm looking for people to join our beta. We're gonna basically blast out mid-July, hopefully. So we'd love for you to join if you're interested to make the product better, to sanity check us. Basically, that's it. And you can also reach me online or outside. Happy to talk more. Thank you.

Reading tools

Type to find a passage

Appearance
Ask this transcript

Add a note