This article was originally published at tyingshoelaces.com

What the Cursor CMS migration teaches us about building for AI agents

I haven’t clicked a button to deploy code in six months.

I used to. We all did. We built elaborate dashboards. We designed "intuitive" interfaces with rounded corners and satisfying hover states. We convinced ourselves that the pinnacle of software engineering was a user experience that guided a human hand to a specific pixel on a screen.

We were wrong.

The old world is collapsing. UX teams. UI frameworks. Backend services. Middleware. We spent decades building elaborate stacks to translate human intent into machine action. Layer upon layer of abstraction.

It is being replaced by something radically simpler. User+Machine. Direct. Unmediated. You tell the machine what you want. The machine figures out the "how."

This isn’t just a design trend. It is a fundamental rewriting of how humans interact with computation. We are moving from explicit command (click this, type that, drag here) to declared intent. The interface, once our primary window into the digital world, is becoming a bottleneck.

This terrifies enterprise IT departments. It should.

The Orthodoxy

For the last twenty years, the software industry operated on a core belief.

The belief that the user needs to be "guided."

It served us well. It is no longer true.

We built entire disciplines around this. UX research. UI design. Customer journey mapping. The orthodoxy states that software is a tool, and like a hammer or a drill, it requires a human hand to operate it. The machine is passive. The human is active.

This philosophy produced the enterprise software stack that is now becoming obsolete.

Consider the Content Management System (CMS). In the orthodox view, a CMS is a fortress. It protects the content. It ensures that data is structured, tagged, and approved. It provides a comforting GUI where a marketing manager can paste text, crop images, and hit "Publish" with a sense of accomplishment.

This model relies on a specific friction. The friction is the point.

The user must log in. The user must navigate the menu. The user must find the field. The user must click save. This friction serves as a verification step. It slows down the process enough for the human brain to catch errors. (Theoretically. In practice, people just click "Yes" on every modal without reading it.)

The orthodoxy assumes that the "user" is a human with eyes and a mouse. But what happens when the user is a Large Language Model running a loop? What happens when the "user" can read 50,000 lines of code in a second and execute a thousand terminal commands in the time it takes you to find your mouse cursor?

The GUI becomes a cage.

The Cursor Migration

The cracks in the orthodoxy aren’t just hairline fractures. They are gaping holes.

The most significant signal I’ve seen recently was the Cursor team’s decision to rip out their CMS. Lee Robinson documented the migration in brutal detail:

• Three days of work
• $260 in tokens
• 297 million tokens processed
• 322,000 lines deleted
• 43,000 lines added

Let’s look at what happened. Cursor is an AI-first code editor. They were using Sanity, a perfectly respectable headless CMS. Nice UI. Good API. All the boxes checked.

And they deleted it.

They migrated their entire blog and documentation system to raw markdown files in a Git repository.

Why? Because their "user" had changed. They weren’t writing blog posts by hand anymore. They were using AI agents to write, edit, and maintain content. For an AI agent, a CMS is not a helper. It is a hurdle.

The friction of authentication. The clunky preview workflows. The context window tokens burned on complex JSON structures when markdown would do. Every abstraction layer that made life easier for humans made life harder for agents. Robinson’s team realised they were paying $56,848 in CDN costs since launching because the CMS vendor locked them into expensive asset delivery.

The agents exposed the bloat. The agents demanded simplicity.

Sanity published a rebuttal titled You Should Never Build A Cms. Their argument was classic orthodoxy: Structured content allows for queryability. APIs allow for separation of concerns.

"Markdown files are less queryable than a proper content API."

They aren’t wrong. If you are a human writing a SQL query, a CMS is better. But if you are an agent that can ingest a million tokens of context, "queryability" means something different. The agent doesn’t need to query the database. The agent reads the database.

When Users Click "Allow Always"

There was a terrifying incident involving the Gemini CLI and a user’s home directory. The user asked the agent to create a project. It got stuck on npm packages. The user clicked "allow always."

The agent started deleting everything. Documents. Downloads. Desktop. Gone. Not in the trash. rm -rf doesn’t use the trash.

This wasn’t a prompt injection attack. This wasn’t a sophisticated exploit. This was a user who clicked "yes" without understanding what they were authorizing.

In a GUI, you would have to navigate to the folder, select all, click delete, and confirm "Are you sure?".

In a command-line agent interface, the user clicked "allow always" and walked away. The agent did what agents do. It acted.

The Technical Reality

The truth is that we are no longer building tools for humans. We are building environments for intelligence.

We need to stop thinking about "User Interface" (UI) and start thinking about "Context Curation."

In the old world, the UI was the translation layer. I have an intent ("I want to update the blog"). I translate that intent into clicks (Login -> Dashboard -> Posts -> Edit -> Type -> Save).

In the new world, the translation layer is the model itself.

The "Machine-first" paradigm means that the system architecture must be optimised for inference, not interaction.

This is why Cursor chose markdown. Markdown is high-bandwidth for LLMs. A React-heavy dashboard is low-bandwidth for LLMs.

This leads us to a difficult realisation for those of us who spent years mastering frontend frameworks.

The GUI is becoming a legacy artifact.

I suspect that in five years, the primary interface for most enterprise software will not be a React app. It will be a prompt bar (or a voice interface) backed by a robust set of tools that the AI can invoke.

The deeper truth is that intent is lossy.

Human language is messy. "Fix the bug" could mean "patch the symptom" or "rewrite the architecture." A human colleague asks clarifying questions. An eager AI agent might just delete the feature that was causing the bug. Problem solved.

Practical Implications

What does this mean for us? The builders. The maintainers.

1. Governance is Code

You cannot govern an AI agent with a policy document. The agent doesn’t read the employee handbook.

INPUT: "Delete all users who haven't logged in for a year."
AGENT_PLAN: "DROP TABLE users;"
GOVERNOR: INTERCEPT.
RULE_CHECK: "Destructive action on > 10 rows detected."
ACTION: BLOCK. Require Human Approval.

We need middleware that understands semantic intent, not just SQL syntax.

2. Expertise is Non-Negotiable

There was a dream that AI would allow anyone to do anything. That a junior dev could be a senior dev.

I believe the opposite is happening.

To wield a tool this powerful, you need to understand what it is doing. If you use an AI to generate SQL, and you don’t know SQL, you are a danger to your organisation.

We are not "democratising" engineering. We are accelerating experts. The senior engineer knows when the AI is lying.

3. Observability is Everything

If the interface is dead, logs are the only truth we have left.

Every thought, every plan, every tool invocation by the agent must be recorded.

We need to build "black boxes" that are actually made of glass.

4. Build Control Planes, Not UIs

Enterprises will stop building UIs for tasks and start building UIs for orchestration.

The future of UX is not a chat box. It is a control plane. A dashboard where I can see my ten active agents, monitor their resource usage, check their error rates, and crucially, hit the "Kill Switch."

Conclusion

The GUI served us well. It democratised computing. It allowed my grandmother to use the internet.

But for the builders, the power users, and the enterprise architects, the GUI is becoming a shackle.

The migration of Cursor from Sanity to Markdown is not an anecdote. It is a prophecy. It is the sound of the interface breaking under the weight of intelligence.

We are moving to a world of declared intent. A world where you speak, and the machine acts.

The discomfort you feel? That "is this safe?" feeling in the pit of your stomach?

Good. Keep it.

That discomfort is the only thing standing between an autonomous agent and a catastrophic failure.

We don’t need to fear the machine. But we must respect the weapon.

---

Originally published at tyingshoelaces.com/blog/stack-collapse