Getting to the source

Victor's argument was deceptively simple: creators need an immediate connection to what they create. Change something, see the effect. Instantly. He demoed a game where you could scrub a character's jump arc backward and forward through time while editing the code that produced it. He tweaked a line of code and watched a drawing of a tree sprout new branches as he typed. A room full of engineering students sat there watching him casually dismantle the assumption that making software has to feel like mailing letters to a compiler and hoping for a reply.

One of the people that talk reached was our founder, Vlad Magdalin. It's not a stretch to say Webflow exists because of it. The whole premise of our company, that you should design for the web by directly manipulating the thing itself instead of writing code and refreshing a browser, is Victor's principle applied to the web.

Which is why it stung when Victor himself told Vlad, years later, that he didn't think Webflow held true to that principle.

Ouch. But here's the thing: he was right. And we’re doing something about it.

Window shopping

Time for the uncomfortable part. If you've ever peeked under Webflow's hood (and in fairness, we welded the hood shut, so don't feel bad if you haven't), here's what you'd find.

When you design in Webflow, you're not actually manipulating your website. You're manipulating an internal representation of it, a proprietary data structure that describes your site, which our systems then compile into the HTML, CSS, and JavaScript that browsers actually run. The canvas you see is a rendering of that internal format. The code that ships is generated output you never touch.

So the thing you make and the thing that gets published to the world are two different things, and somewhere between them, something gets lost in translation. (Literally. There's a compiler doing the translating.)

That's exactly the gap Victor's principle exists to close. His point was never "visual tools good, code bad." Plenty of visual tools fail his test, and plenty of code environments pass it. The point was that creators deserve a direct, honest connection to the actual artifact. And for the web, the actual artifact is code. Our internal format made the canvas feel direct while quietly keeping the real thing at arm's length. Sure, you could export your code. But you couldn't edit that export and bring it back home. The source of truth was a format only our compiler could read.

If you'd rather have the engineering version of that complaint than the philosophical one, here it is: any system with two representations of the truth, joined by a translation layer, will drift. And drift compounds. Every action has to round-trip, intent to canvas state to generated code and back, and every round-trip is a chance for the two versions of reality to quietly disagree. Ask anyone who's maintained a system like that how it goes. (Actually, don't. They've suffered enough.)

The beautiful trap

Now, before this turns into ten paragraphs of public self-flagellation (tempting, but nobody needs to see that), let's be honest about the other side of the ledger: that abstraction is why Webflow works at all.

In 2013, there was no realistic way to hand a non-engineer raw HTML and CSS and wish them luck. The web platform is gloriously, historically messy – three languages doing an awkward dance, decades of accumulated quirks, and a box model that has personally humbled both authors of this post. A clean internal representation was how Webflow tamed all that. It's what made the canvas fast, the styling coherent, and the output reliable. Millions of sites got built by people who couldn't have built them any other way, and we're enormously proud of that.

So two things are true at once. The abstraction opened the web to a generation of visual developers, and that very same abstraction also separated them from their creation. The trap and the superpower were one piece of architecture. Given 2013's constraints, we'd make the same call again tomorrow.

It's not 2013 anymore.

Enter the agents

Remember the moment in The Matrix when Neo finally sees the code? The green rain stops being noise and starts being readable, and suddenly the whole world is something he can reach out and change. That's roughly what just happened. For everyone.

Coding agents can now read, write, explain, and refactor code well enough to make code itself available to people who will never type a semicolon. You can point at your site and say "make this heading bigger on mobile," and an agent makes that change, in the real code, the actual artifact, and shows you the result. The truth is, code was never the enemy. Code was just unavailable. It sat behind years of syntax and setup and stack traces, so an entire industry (hi, that's us) built abstraction layers on top of it, and every one of those layers traded away a little connection to the artifact in exchange for approachability.

For years, that was a good trade. Agents changed the game. When anyone can have a conversation with code, hiding the code stops being a kindness and starts being a cage.

The agentic future isn't knocking politely. Over 30% of our enterprise customers are already running agents against production Webflow sites with our MCP, and that number has grown roughly 4x since January.

And that changes what's possible for Victor's principle. For it to fully hold on the web, the thing on your canvas and the thing that ships need to be the same thing, which means the source of truth has to be code, because code is what the web runs. The only reason that was ever a non-starter is that "the source of truth is code" always carried an unspoken second clause: “and therefore you need to know how to write it.”

Agents deleted the second clause. So we're acting on the first.

Code, sweet code

We're rebuilding Webflow around code as the source of truth.

Not code as an export format. Not code as an escape hatch for the developers on your team. Code as the canonical artifact. The thing the canvas renders, the thing agents manipulate, the thing you own. The visual designer and the AI conversation become two views of the same real thing, instead of two interfaces to an intermediate format you can't see, read, or take with you.

If you've been paying close attention, you've felt this coming. MCP 2.0 shipped governance, branching, and permission enforcement because agents needed the same guardrails a person gets, not fewer. AI Code Components exist because agents and people both needed a way to generate production React directly against the design system. The move to a next-gen headless CMS with real content delivery APIs happened because content needed to be addressable by something other than Webflow’s page renderer. Those weren't independent bets. They were the foundation going in, one beam at a time.

We're not going to walk through timelines or feature lists here, because this isn't an announcement of a release. It's an announcement of a direction. (And, if we're honest, a conviction we've been circling for a long time.) But the implications follow naturally once the foundation shifts. What you make in Webflow becomes yours in the fullest sense: readable, portable, real. What you see is what ships, because they're the same thing. And the immediate connection Victor demanded finally extends past layout into the whole artifact, structure, style, behavior, all of it.

We won't pretend this is a small lift. Rearchitecting a platform that millions of people rely on, around a fundamentally different source of truth, is the hardest engineering work this company has ever taken on.

And if you're reading this with one eye on the site you've already built, the one your business runs on, hear this part clearly: your site isn't going anywhere, and neither is the way you work today. We're building the bridge before we ask anyone to cross it.

The starting line

If you're keeping score at home, you might be raising an eyebrow right about now. Code-first tools already exist. Lots of them. Some are very good. So is this whole post just us talking about...catching up?

Partly, yes. Every serious tool in this category is racing toward the same conclusion, for the same reason: agents read and write code, so code has to become the real thing. That gets everyone to the same starting line. It's not where we intend to stop.

Because here's what a decade of serving marketing teams taught us that a code editor never had to learn.

A prototype that runs in a browser is not an enterprise-grade experience. Every code-generation tool eventually runs into this, usually around the time a real client shows up with a real brand, real users, and a real Tuesday-afternoon deadline. Generating the thing turns out to be the fun 20%. The other 80% is shipping it to production, keeping it on-brand, and letting an entire team work on it without anyone, or anything, breaking what's live.

Because the web is a team sport. A marketer, a designer, a developer, an agency, and increasingly an agent (or five) will all touch the same site in the same week — and they don't all want the same tool. The marketer wants to ship a page and watch it perform. The developer wants to extend a component without fighting the canvas. The agent doesn't want an interface at all; it wants an API and a boundary it isn't allowed to cross. Most code-first tools were built for a single developer working alone against a single repo — an assumption that doesn't survive contact with a dozen agents hitting production in the same afternoon. We've spent years building for the opposite: many hands, one system, the right interface for the right team members at the right time — with guardrails so nobody ships something off-brand while you're at lunch.

And launch day? Not the finish line. The opening whistle. The site you ship is also the site that reports back: what's converting, what's getting found, what deserves to change next. Closing that loop, from building to learning to improving, is where this stops being a better tool and starts being something else entirely.

So, catching up? Code as the source of truth is the price of admission. Your whole team, humans, agents, and agencies, working on the same real thing with results that compound after launch? That's the story we can't wait to tell you.

The next chapter

In "Inventing on Principle," Bret Victor says that people who live by principles aren't really designers or engineers. They're activists. Their principles are claims about what's wrong with the world, and a promise to fix it.

By that standard, Victor's critique of Webflow was never an insult. It was the same invitation the talk extended to Vlad Magdalin in 2012: the work isn't finished.

He was right then. And the honest truth is we couldn't finish it, not with the technology of that era, not while keeping the door open for the people who needed it most. What changed is that the world finally built the missing piece.

Creators need an immediate connection to what they create. For the web, what you create is code. Now we get to honor that. And it's further along than anyone outside this building would guess. We could write another few thousand words trying to describe it. We'd rather just show you.

We're unveiling it at Webflow Conf this September: the canvas, the code, and the moment they become the same thing. Grab tickets before they're gone. Webflow’s been building towards this moment for over a decade. We'd love for you to be in the room.