Why AI-native workspaces.

Every app is CRUD

Strip the branding off any SaaS product and you find the same four operations. Create a record. Read a record. Update a record. Delete a record. Spreadsheets do it. Salesforce does it. QuickBooks, Notion, Linear, Figma, all of them.

Workflows get layered on top. Approvals, pipelines, notifications. But underneath the workflows, the primitive is still CRUD. That's the shape of software.

Call this a workspace. When I say "workspace" in this essay, I mean any piece of software that does CRUD on data a human cares about.

Automation hit a ceiling

Since the first workspace, engineers have tried to automate parts of it. Automation is a script. A script runs the same steps every time.

This works beautifully until something unpredictable happens. A new type of file. A weird customer. A rule nobody wrote down. The script breaks, and a human has to step in.

Pre-GPT chatbots hit the same wall. Real conversation is unpredictable. Scripted responses can't keep up. Chatbots got a bad reputation, and earned it.

The lesson from both: if your problem has edge cases, a script is the wrong tool.

ChatGPT arrived, and couldn't touch the workspace

Then ChatGPT showed up, and suddenly unpredictability wasn't a problem. You could talk to it about anything. It would figure out what you meant.

There was one catch. ChatGPT couldn't touch the workspace.

The AI reads text and writes text. The workspace lives in databases and files, behind buttons and forms. The two systems couldn't see each other.

So users improvised. They copied context out of the workspace. They pasted it into ChatGPT. They read the response. They typed it back into the workspace by hand.

The human became a USB cable between two systems that couldn't talk to each other.

It worked, because the alternative was nothing. But it was the worst possible integration pattern. Most of the user's time went to plumbing data between tools, not doing the actual work.

AI as a feature doesn't scale

The next move was obvious. Engineers built AI into their workspaces directly. A "summarize with AI" button. A chat box in the corner. A "generate" option in a menu.

This is the pattern nearly every SaaS product uses today, including some of the most polished software being shipped. It's not a story about bad products. It's a story about an architecture that has a ceiling, no matter how well it's executed.

Here's a concrete example. Imagine an accounting app where the AI could help classify documents. Useful feature. Someone adds a "classify with AI" button. Great.

A week later, a user wants the AI to also suggest which clients are at risk of churning. There's no button for that. The AI never sees the request. Someone files a feature ticket. Six months later, if the feature is popular enough, a new button appears.

But the user wanted ten things, not one. For every action the user might want the AI to help with, the engineers have to ship a button. Every button needs a design, a backend, a review cycle. This can't scale.

The root cause is simple. The AI only has access to the capabilities the engineer pre-decided to expose. Everything outside that small surface is invisible. Even if the AI is smart enough to solve the problem, it's caged.

Cursor changed the shape

Programmers lived through every stage of this mess. They invented solutions as the pain got worse.

Stage one. Copy code into ChatGPT. Get a suggestion back. Paste it into the right place in your editor. Hate your life.

Stage two. Cursor put the chat inside the editor. Less tab-switching. Still the USB-cable pattern underneath.

Stage three. Cursor let you reference files from the chat. The AI could pull context itself. Faster. Still "advising" the programmer.

Stage four. Cursor started suggesting where to insert code changes directly in the file. The AI was pointing at the right place, but the programmer still had to click accept.

Stage five. Cursor gave the AI tools to create, read, update, and delete files directly. No more suggesting. The AI was editing the codebase.

Stage five is where the world changed, and most people missed it.

The AI wasn't advising a programmer anymore. The AI was programming. Same codebase, same operations, same files. The human edited through the UI. The AI edited through its own tools. Both were operators. Full CRUD parity.

For the first time, the AI was inside the workspace. Not glued to the edge of it.

AI-Native Workspaces

Nobody has named this pattern yet. People describe it by pointing at examples. "We're building the Cursor for accountants." "We're Claude Code but for lawyers." Clear enough to sell a product, not clear enough to teach.

Here's the definition, in one sentence.

An AI-native workspace is a digital environment where the AI and the human share all CRUD operations on the same data.

That's the whole concept. Everything else follows from it.

A short test. A workspace is AI-native if all four of these are true:

1. The AI can create data in the workspace without waiting for a human to click a button.
2. The AI can update and delete that data through the same path.
3. The human sees what the AI did in real time, through the normal UI, without refreshing or reopening anything.
4. There is a chat where the human can ask the AI to do anything the human could do by hand.

Four yes answers: AI-native. Anything less: not yet.

Why this matters beyond code

Coding was first because programmers build their own tools. Every other role has been waiting.

But CRUD is universal. The shape Cursor and Claude Code found works everywhere. Bookkeeping is CRUD. Compliance is CRUD. Sales pipelines are CRUD. Legal review is CRUD.

As soon as any of those jobs gets a proper AI-native workspace, it will get the same 10x to 50x jump that coding got.

Every SaaS today is trying to glue AI in after the fact. Most will ship a chat sidebar and call it innovation. Every one of those jobs is still waiting for its Cursor moment.

That's why I decided to build Houston.

What Houston is

Houston is three things at the same time.

For non-technical users, it's an app you download. You install an experience someone else built (a bookkeeping workspace, a legal research tool, a sales pipeline) and you get Claude Code's power inside a UI built for your specific job. No terminal. No forty-hour setup.

For developers, it's a framework for building those experiences. You write normal React and Rust. Houston handles the parts that are universal: files as the source of truth, the chat as the control surface, the AI as a co-operator. You publish a repo. Other Houston users install it with a link.

For founders, Houston is a way to skip the six months you'd spend rebuilding AI-native plumbing that already exists. Fork it. Rename it. Build a vertical workspace on top. Your code, your customers, your moat. If you hit something missing in the base, send it back as a PR.