Why Client-First V3 Is the Best Framework for Webflow MCP
Watch on YouTubeAbout this video
With the recent release of Client-First V3, I wanted to share why I think Client-First is the best framework for building websites with AI using the Webflow MCP.
I've been a fan and avid user of Client-First for years; and recently I had the opportunity to work with the Finsweet team as a contributor to the docs for the V3 update! After testing the Webflow MCP across major frameworks like Client-First, Lumos, and Mast, I've found that Client-First offers some real advantages when working with AI agents.
In this video, I'm breaking down 3 reasons why I think Client-First works best with the Webflow MCP.
1. It works with the current limitations of Webflow MCP.
The MCP is great at creating and managing classes and styles, but it still struggles with things like components, slots, and conditionals. Client-First doesn't rely as heavily on those features, making it easier for AI agents to work within the framework.
2. AI agents already understand Client-First.
Thanks to its widespread adoption, documentation, and tools like Relume, Client-First naming conventions are already familiar to many AI models. That means less time explaining your framework and more time building.
3. It gives AI better building blocks.
Client-First V3 provides structured class naming, style guides, and variables that give AI agents clearer instructions and more context. Instead of guessing or creating unnecessary classes, agents can reference your existing system and work more consistently.
We'll also look at how Client-First compares to Lumos and Mast, why component-heavy frameworks can be challenging for the current MCP, and how V3 improves the overall system.
While every framework has its strengths, I think Client-First is currently the easiest and most reliable option for AI-assisted Webflow development.
What's your preferred Webflow framework when working with AI? Let me know in the comments!
Resources
Chapters
- 00:00 Introduction
- 00:29 What Is Client-First?
- 01:26 Reason #1: Webflow MCP Limitations
- 03:35 Reason #2: AI Agents Already Understand Client-First
- 04:40 Reason #3: Better Building Blocks for AI
- 06:48 Final Thoughts
Full transcript
1,610 words
Hey everyone, here's why I think Client First is the best framework for the Webflow MCP. We just had the release of Client First V3. Client First is a naming convention for Webflow classes that was created by Finsweet, which is a development agency in our space. Finsweet has given away a ton of resources and tools and plugins and things to help our community get better. So, let's do a quick primer on what Client First is, and then I'm going to give you my reasons why I think it's the best and the easiest way to use the Webflow MCP.
Before Client First, we really didn't have a lot of standards for how things were named in Webflow. People were using things that were borrowed from Bootstrap or from BEM style naming conventions. Client First was really the first framework that blended the best development practices with Webflow specific nuances and features, like how Webflow handles combo classes, for example. It creates a combo class that's a chain of classes, and that specific chain has specific CSS tied to it, and that doesn't exactly follow cascading style sheets.
So, you kind of have to understand those nuances. Client First was really built just for that specific thing. Once I read that and got the hang of it, I was pretty much hooked from day one. I've been using Client First for a number of years. In addition to using Client First for a number of years, I also got to be a contributor on the version three. So, I know I'm a little bit biased, but I do have my reasons why I think Client First is really the best way to work with the MCP, and I'm going to put the results and the work that I did in a repo, so you can actually review my work or have your agency review my work, and I'll link it here in the comments.
My first reason is the current MCP limitations. There's a couple of different things that the MCP can still do well, a couple of things it still struggles with. I put up a video about it a couple weeks ago, and I think most of those things are still true. The things that it can do really well are create classes, name classes, add classes, add styles, and, you know, work in styles. All of that stuff works quite well, and that is where Client First really does most of its work.
You can just use it with classes and styles and working from a style guide. That's kind of where Client First is focused. The things that MCP currently does pretty poorly still or struggles with are things like components, component slots, conditional visibility, and not just conditional visibility, but Webflow calls them conditionals. It's the new feature that you can create a conditional for if a certain property is filled, then it shows or hides something on the canvas.
And that particular thing right now is not even in the MCP anywhere. You may build something with a conditional, and then the MCP can't see it, and it just writes over what you've done. So, since it can't see it, it doesn't know it exists, and it's kind of a pain. All those conditionals and slots and components are really more heavily relied upon by these other two frameworks. Mainly, I'm thinking of Lumos or Mast. They really rely on components and nested components and slots and all those things.
So, because the MCP can't quite use those or see those as well, it leads me to think that it's not really very easy to use those other two frameworks. So, not to say that you can't do it in those other frameworks. Especially, Lumos is really component-heavy. Client-First is a little more agnostic about where you use components and how you use them. And since the MCP sometimes struggles with that, I still think Client-First is the easiest way to work in Webflow.
And again, I tested this across all the major frameworks with the MCP, and the other frameworks do seem to rely more on components. Because Client-First doesn't really care if you use components or not, I think it's just easier to work sometimes without that, and then you can manually make the components that you need. I think the other two frameworks do rely more on components, especially Lumos. So, it makes it a little harder for me to want to use a Lumos build with the MCP if half the time the MCP connection is not going to quite understand what I'm saying.
So, again, I hope that changes soon. I I'm assuming that the MCP will just continue to improve. So, hopefully, that will change in the next couple of months. Currently, that's where it stands for me. Point number two is that agents already speak Client-First. The Client-First naming convention is component name {underscore} element. Might be hero {underscore} layout or hero {underscore} right section or whatever you want to say.
That framework, specifically, was really popularized by Finsweet and Relume. Relume being another software that uses the Client-First naming convention. All that stuff has been really popularized. And I think it's all been pretty well documented as well. So, those are two things that the AI agents just eat up. They love that kind of stuff. Potentially, there's just more training data overall. And I think Client-First is a little more ubiquitous on client sites as well because it's been around for a long time.
Again, the Relume stuff has been pretty well received. Those reasons lead me to believe that it's almost built into the models that this naming convention is just very common. I've even experienced in my testing that when I say build this in Lumos, you know, I'm using a Lumos site, it'll default and reach for Client-First names even if it knows that it's not a Client-First site just because that's what it is used to. Those models are used to using those words.
So, that's a reason for me that the Client-First framework is just easier to use because the models already want to talk in Client-First. And my last reason is the Client-First uses strong building blocks. So, especially with V3, the Client-First system has leaned into really clean building blocks. And mostly what I mean is like a style guide with a bunch of class names and variables. One of the main critiques of the Client-First system is that it uses more classes than other systems and it has sometimes more words.
But, some of those things give you more context for the AI tools to know what's going on, especially when it comes to like a style guide with all the classes written out. That can be really helpful for you to just point your AI back at the style guide and say, "Don't make any new classes. You have to use what's already here." Or, you know, "Look at this site and look at the components. What's already built?" For example, some of these other systems like Lumos or Mast have free entry text fields where you can enter in a class name or a combo class versus just using an existing modifier versus just using a combo class from the style guide.
And those free entry fields are pretty hard for the AI to understand what they should put in. Uh sometimes the tooltips won't get pulled into the context properly or you have to just be explicit that this property you have to put in dark or light. That's just something that in Client-First, the system can look back at the style guide and read those classes and read what's available and look at the combo classes that it has at its fingertips.
So, that's a reason for me that Client-First is just more streamlined and easier to use for these agents. Also, with the release of V3 for Client-First, we have more variables available to us. That's just another way that the system can be expanded and be more powerful. The system hadn't been updated for a while, so there were some missing gaps in the variables coverage, especially when it comes to like a color theme. Some of the other systems were a lot farther ahead, but I think Client-First has caught up a little bit to that with the release of V3.
Now, just on a personal note, too, I think Client-First is not as reliant on CSS formulas. And for me personally, I found those to be quite buggy in the MCP, and also just hard to read in the UI. So, it's one thing to write a custom code block with some CSS variables, but when you go into the Webflow UI, you're clicking two or three times, and you have to use keyboard shortcuts sometimes. It's just a pain for me to want to use those formulas, so I do like that Client-First doesn't rely on those things as much as the other tools.
I know there's some different responsive tradeoffs, but for me it's just a personal preference that I'm not really a fan of those formulas. It's true that I am much more familiar with Client-First, but I've done some homework here, and I'll put that again, I'll put it up so you can review it. So, fight me if you want, but I still really think that most of these models can speak Client-First a lot more fluently, and for those reasons, I think Client-First is the best way to work in Webflow.