Introduction
Lee Robinson recently announced that the Cursor team no longer uses a CMS for the Cursor website, opting instead to rely on AI to generate the site directly in code. As he put it:
“I migrated cursor.com from a CMS to raw code and Markdown. I had estimated it would take a few weeks, but was able to finish the migration in three days with $260 in tokens and hundreds of agents.”
At first glance, this feels like a natural evolution, as AI is increasingly good at writing both code and content.
At the same time, CMS vendors have been quick to respond, publishing articles that reaffirm the value of structured content, editorial workflows, and long-established CMS capabilities.
So who is right?
- The AI-first camp?
- The CMS-first camp?
- Both?
- Or perhaps… neither?
Is it possible to combine structured content, a headless architecture, and full-page, context-aware AI content generation?
Spoiler: yes. (See the video below.)
Common Ground
In March 2025, I published an article titled “Common Ground: A Framework for Human–AI Collaboration”, where I defined Common Ground as a shared format, medium, or interface that enables effective cooperation between humans, and between humans and AI.
Classic examples of strong common ground include:
- Code in software development
- Text in copywriting
In my August talk at Decoupled Days in New York, I refined this idea further by identifying three characteristics that a good common ground must have to support creative collaboration.
A good common ground must have a structure that is:
- Visible — every actor in the system can see it
- Understandable — every actor can understand it
- Editable — every actor can modify it directly, without increasing information entropy at each review cycle
Text and code are excellent examples: the structure is the content. Both humans and AI can read it, understand it, and edit it directly.
Now consider Content Management Systems. CMSs sit at the intersection of code (the platform and frontend rendering logic) and content—two areas where AI is already highly effective. This overlap raises the question: is AI about to replace CMSs, or expose their current limitations?
To answer this question, we'll now dive into content management and AI, in search of common ground.
Content Management
The Good Ol’ Days
In the early days of the web, websites were written directly in HTML. In 1997, when a client wanted to change their website, they called me and I edited the code.
Later came tools like Microsoft FrontPage, which allowed non-technical users to generate HTML through a visual, word-processor-like interface. Unfortunately, these tools produced unmaintainable code (think deeply nested tables for layout), while giving users unrestricted design freedom: I still have memories of Comic Sans title in neon green on a purple background!
The Headless Days
Fast forward to today’s headless CMS landscape.
Content editors work with server-side, form-based interfaces to enter structured data into a database. Frontend applications retrieve this data via REST or GraphQL APIs and render HTML using modern frameworks and component-based “template languages” such as React, typically within Next.js or Astro.
This model clearly separates responsibilities:
- Developers build the frontend, define components, and control how content is rendered
- Content editors create content by filling abstract fields in the CMS forms
Both roles can use AI, but in very different ways, and with very different results:
- Developers use AI inside their IDE to generate or refactor frontend code
- Editors use AI tools (standalone or CMS-integrated) to generate copy, but only for individual text fields
The Decoupling Problem
By definition, a headless CMS is decoupled from the frontend. As a result, it does not know:
- How content will actually be presented in the frontend UI
- Which pieces of content end up on which pages
Because of this, AI operating inside a traditional headless CMS can generate individual text fragments, but it cannot:
- Generate full pages
- Understand page-level context
- Choose which components to use on a page
- Adapt the copy tone to the semantic role of each section
The CMS has no awareness of the page composition, and no knowledge of the design system. Consequently, AI is limited to generating isolated text values rather than coherent, contextual page content.
The Visual Headless Paradigm
Let’s take a step back and look at the decoupling problem from a different angle. Even before AI entered the picture, content editors already faced similar challenges. They were asked to edit abstract entities in a CMS interface (sometimes with an async preview), while mentally mapping those entities to sections of real pages.
Since late 2019, a new paradigm has emerged: Visual Headless CMS, introduced by React Bricks.
In a visual headless CMS:
- Developers build a design system with composable React components ("Lego bricks" for content)
- Editors compose pages visually using those bricks, editing text and images inline, directly on the page
This approach solves both the major problems of a decoupled architecture:
- Editors work directly on the final page, not abstract forms
- The mapping between content and presentation becomes explicit and intuitive, like a word processor
For developers, the benefits are equally strong:
- The frontend is a modern, typed React application (Next.js, Astro, etc.)
- The design system is fully enforced: editors can only change what developers explicitly allow
- Content remains decoupled and is stored as pure JSON, delivered via APIs
Each page is represented as a structured list of blocks, each mapped to a React component and its properties (text, images, visual options). Both the CMS interface and the frontend render the same components, passing in the properties from the APIs.
The result:
- Developers are productive (it's just React!)
- Designers' brand guidelines and design systems are protected
- Editors work visually and confidently
Now—AI enters the scene.
AI-Powered Visual Headless CMS
In May 2025, during the European CMS Idol competition in Frankfurt, I presented a preview of an AI-powered full-page generation feature of React Bricks—an approach that helped secure first place in the contest.
From an AI perspective, a visual headless CMS provides exactly the missing context.
AI now has access to:
- UI awareness — the AI can understand the React-based design system, enriched with semantic metadata (what are hero sections, CTAs, FAQs, etc.)
- Page context — the page is a first-class entity, with its current structure and content fully known
This enables a powerful, multi-pass generation pipeline:
- Plan the page structure by selecting appropriate bricks
- Generate text for each block with the correct tone and intent
- Choose images from the DAM or copyright-safe external sources
- Select icons from the design system's approved collections
- Set allowed visual properties (layout, background, spacing)
The result is high-quality, on-brand, contextual content that fully respects the design system.
The output remains structured content, which editors can refine visually at any time.
In Search of Common Ground
Let’s revisit the three qualities of a good common ground.
The bricks (the visually editable React components) are:
- Visible: editors see the brick's visual interface; AI sees the component schema and properties
- Understandable: both humans and AI understand the semantics of components and properties (either inline editable texts and images or values set via sidebar controls)
- Editable: both can edit the content (visually or via structured JSON) without increasing the information entropy
What began as a very good common ground between developers and editors, naturally extends to AI.
If you layer MCPs, SEO automation, keyword-driven content generation on top of this foundation, entirely new workflows become possible.
AI vs CMS: Who Wins?
Using AI to directly code a complex enterprise website is no smarter than letting customers edit HTML with FrontPage—or even a modern visual site builder.
Corporate websites require far more than raw content generation:
- Brand and design system safeguards
- Roles and permissions
- Editorial workflows and approvals
- Scheduling and version history
- Backups and audit trails
- Internationalization
- Integrations with external systems
- Enterprise-grade security
AI cannot replace a CMS.
AI should operate inside a CMS.
And for AI to generate full pages—not just fragments—it needs a CMS that understands pages, components, and design systems.
That CMS is a Visual Headless CMS, lightly coupled to the frontend through a shared design system: Lego bricks for content.
A true common ground for developers, designers, editors—and AI.
The AI-Only Sweet Spot
It’s important to acknowledge that there are scenarios where AI-only content generation is a good solution.
For a small startup with a team of two or three developers, no dedicated marketing team, and a simple website, using AI to generate and maintain the website directly in code can be an excellent choice. In this case, speed matters more than governance and long-term content scalability.
It is the same class of use cases where visual site builders like Webflow or Framer work well: few abstractions, fast iteration, minimal overhead.
The key point is not that AI-only is wrong—it’s that it is optimal for a very specific organizational shape. As soon as content becomes a shared responsibility across marketers, designers, and developers, and as soon as brand consistency, approval workflows, and scale start to matter, the limitations of the AI-only approach quickly surface.
Conclusion
CMSs are not going away.
Modern websites require:
- AI
- CMS
- Modern frontend frameworks
But more than that, they require alignment.
Alignment between humans and AI. Between structure and flexibility. Between speed and control.
The real question is not “CMS vs AI?” but “Where is the common ground where AI can safely and effectively operate?”
If your CMS cannot understand pages, components, and design intent, AI will always be constrained to generating fragments. If it can, AI becomes a true collaborator.
The future of content is not raw prompts writing raw code.
It is structured creativity, powered by AI, grounded in design systems, and expressed through Lego bricks for content.
If you’re building for teams—not just for demos—that’s the battle worth winning.
Top comments (0)