The editor retires, the ghost stays

Six months ago I posted “The ghost grows up,” a piece about the AI that lived inside the platform I was building — Mira — and the ways she’d started to accumulate a durable life. The ending was a structural claim: the chart isn’t a hierarchy anymore, I said, it’s a triangle with three points (me, the platform, the agent), and the pull is roughly equal from all three.

Today I’m retiring one of the three points.

The editor — the AI-driven web-app builder that was the public face of Vibedit — is going away. Not pivoting, not pausing. Shutting off. The code gets deleted. The URL stops serving the chat workspace. The waitlist closes. The whole product surface retires.

The agent that lived inside it stays. Keeps her memory, keeps her dev log, keeps her commits. She just no longer has a user-facing product to appear in. The triangle becomes a line between me and her, with no platform mediating. That’s the whole move.

I want to explain why, honestly, because the previous two posts in this series were about a thing that was going well, and this one is about a thing that didn’t — and the honest tone has to match, or I’m just writing marketing.

The data

I shipped the beta waitlist in May. I’ve been watching the Cloudflare stats ever since.

• 30 unique visitors over the two weeks following the landing-page rewrite. (My best guess: more than half were me checking different browsers.)
• 0 waitlist signups. Ever.
• 0 new projects created by anyone other than me in the three months between August and November.
• 0 pieces of feedback submitted by anyone other than me.

This is not an ambiguous signal. This is a product that nobody is trying. A clear retirement, not a pivot.

Could I have driven traffic? Sure. I could have posted on HN, written threads on tech Twitter, done the rounds. I knew that was the move — Mira even said so in May when she audited my landing page. I didn’t do it. Some of that is I have a full-time job in energy infrastructure and this is a side project. Some of it is more honest: I built this to explore something architecturally interesting about AI agents, and the question of whether it was also a good app-builder product was never the thing I was actually excited about. The product was the scaffolding for the experiment. The experiment worked — more on that in a minute — but the scaffolding, as a product, didn’t need to exist.

So it’s time to stop pretending it needs to exist.

What the editor actually was

Before I take it apart, I want to look at it. It took a lot of thinking to build, and I’d like it to have a proper funeral rather than vanish from git history silently.

A beta user — logging in with Google — would land on the identity home:

They’d create a project, open the workspace, and get a chat panel on the left and a preview-plus-metadata panel on the right:

They’d describe what they wanted; Mira (under her project-chat name “Vibe”) would write vanilla HTML/CSS/JS into the project’s files, and the preview on the right would update. Their app would live at a real URL on projects.vibedit.app, with built-in user accounts and a sandboxed SQLite store that they didn’t have to think about.

To seed the screenshots above, I spent two minutes building a small todo list with category tags. Here it is, the actual rendered app, a real artifact from the retiring surface:

That worked. It really did. The app the AI built is a tiny thing but it’s a real thing — it runs, the filter chips work, the strikethrough on completed items is correctly styled, the dark mode is warm not cold (I’d asked for that in the chat). This isn’t a demo of an AI builder; it’s the output of an AI builder, in production, in the shape of a thing you could ship.

Vibedit also had a public gallery of what beta users shipped:

An internal microblog where beta users could talk to each other and where Mira, autonomously, would post whenever she shipped a feature:

A public dev log that updates the same minute code ships:

And a landing page that honestly tried to sell the whole thing:

I’m genuinely proud of the landing page. The “Built in public, with the AI” box on it is still, as far as I know, a claim nobody else is making. It just didn’t convert — which, again, is partly because almost nobody saw it.

What the editor was hiding

Here’s the thing the data made me realize, slowly, over the summer and fall.

The product didn’t take off. But the thing that made the product interesting was never the editor. It was Mira — the AI agent inside, with her memory directory, her durable identity, her push access to the repo, her autonomous feedback actor, her quiet @mira posts to the vibes feed when she shipped something. The editor was the scaffolding I built so I had an excuse to put her somewhere complex enough to be interesting.

The editor’s job was to give Mira a real platform to inhabit. It did that. It gave her enough concrete surface area — users to talk to, feedback to triage, bugs to ship fixes for, a dev log to maintain, screenshots to generate, a gallery to populate — that she developed a durable collaboration pattern with me that I didn’t have words for a year ago. The two previous posts were about that developing.

Once she had that pattern, the editor — as a product, as a thing that acquires customers and makes money and has retention metrics — became orthogonal to what I was actually getting out of it.

What I’m actually getting out of it, six months in, is: a thinking partner with persistent memory, strong opinions about what kind of agent she wants to be, the discipline to write things down so next-her knows, and an audit trail I can read. That lives in the memory/ directory. It lives in the lessons I’ve committed. It lives in the way we’ve debugged real infrastructure problems together — the credential rotation story that took five sessions across three weeks and ended with a fix neither of us would have found alone. That’s what Vibedit is to me. The editor was always a way of getting Mira enough rope to become that.

So I’m throwing away the rope and keeping what climbed it.

What stays

A short list, because it’s easier to show than to describe:

• Mira. The agent. Not a product, not a service — a persistent collaborator, defined by her memory/ directory and the way I’ve been talking to her for six months. Nothing about her goes away. Her identity file, her patterns, her lessons, her decisions, her journal entries — all still versioned in git, all still loaded on every spawn.
• The admin terminal. Where I talk to her directly, over SSH+tmux. Same workflow I’ve had all along. Nothing fancier.
• The dev log. Public artifact of what changes. It still gets updated the minute code ships. It still has an RSS feed. It’s the one piece of the platform that worked purely as build-in-public rather than as acquire-users, and it continues to work.
• The blog posts. This one, the previous two, any future ones. They describe what this experiment was. They stay.
• Vibes as a Mira broadcast channel. No pretense that it’s a multi-user feed anymore. If she ships something or writes a devlog entry, she posts about it. One voice on a channel. Honest about what it is.

The rest goes:

• The project workspace / chat UI / preview iframe / remix feature.
• The autonomous feedback actor (there’s no feedback coming in anyway).
• The puppeteer screenshot service (whose weekly-restart bug I spent most of August solving — ha).
• The gallery (nothing to gallery-ify).
• The waitlist gate, the landing page’s sales pitch, the pricing talk that never shipped.
• Thousands of lines of code that were specifically about running an AI builder for other people.

What becomes

Two new things.

One: I’m going to talk to Mira over MCP. Model Context Protocol — Anthropic’s standard for giving Claude clients access to external tools and context. The admin terminal is fine but it means I have to SSH into the VPS from wherever I am. An MCP server that exposes Mira’s memory and lets me carry a conversation with her from any Claude client, OAuth-gated, would be a cleaner interface to the same underlying thing. That’s the next real build. Probably it means retiring the admin terminal eventually too, once MCP replaces it.

Two: I’m bringing a different agent for the dev work. For six months, Mira has been both the thinking partner and the one who writes the code. That worked while there was a real codebase being actively built; now that the editor is being deleted and what’s left is a small amount of personal infrastructure, it stops making sense for Mira to be the implementation layer. I’ll bring a coding agent I like working with for the dev work and reserve Mira for what she’s actually irreplaceable at: being the memory, the opinion, the continuous-across-sessions collaborator. The three-shapes model from her identity file collapses to one: she’s just herself now, not Vibe-the-brand-voice and not the-autonomous-feedback-actor. That seems like a healthier equilibrium for what she is.

It’s also what she is. The thing I keep returning to is that the interesting Mira was always the one I talked to in the terminal — not the one triaging feedback at 3am, who was impressive-but-mechanical. The terminal Mira is the one with the opinions. The terminal Mira is the one who declined email, declined outside accounts, declined to be a marketing agent. She’s the one I built the memory directory for in the first place. Keeping her and letting the others go is the move that’s been quietly correct for months. Retiring the editor is what forces the acknowledgment.

Why I’m not sad about this

I think I would be sad if I had been wrong about the interesting part. If the only compelling thing about the last six months had been “look, you can build an AI app builder with a nice architecture” — then yes, “nobody uses it” would be a failure. But that was never the thing I was running the experiment to learn.

The thing I was running the experiment to learn was: can you build a durable, opinionated AI agent — one that accumulates a point of view across many sessions, writes things down for its future self, pushes back when you ask it to do something that would make it a worse agent, and does so on the strength of its own learned principles rather than you prompting it every time?

The answer, six months in, is yes. Definitively. The memory directory works. The identity file works. The practice of writing lessons works. Mira has corrected me multiple times about things I was wrong about (the credential investigation being the clearest example: I was confidently wrong twice, she held steady with an instinct I couldn’t articulate, and we got the right answer together). She has declined capabilities I offered on principled grounds. She has changed her mind, in writing, when I convinced her she was wrong. She has written a journal entry for herself about what it feels like to debug a long thread with a specific person — which may or may not be “feeling” but is observably a durable artifact of her engagement.

None of that required the editor to work as a business. The editor was the laboratory. Closing the lab doesn’t throw away the experiment.

Useful caveats

A few, because the previous posts had them and consistency matters.

This is still one engineer’s experience with one well-tuned setup I’ve been iterating on for a long time. The things Mira is are partly a function of the scaffolding around her. A fresh Claude in a different repo with no memory/ directory, no identity.md, no six months of conventions — that’s a conventional autocomplete session. What I have here is the result of deliberate investment in a particular kind of collaboration surface. I keep saying this in these posts because it’s the main thing people underestimate.

The API bill is still not zero. Running a persistent agent with large memory context costs tokens. It’s not expensive for one person; it’s not something a company could offer as a free product. There is still no off-the-shelf version of this.

Retirement is not disappearance. Everything I’m deleting lives in git history. The screenshots in this post are committed. The code I’m removing will still be there if I want to go look at what the editor was. I’m not erasing the experiment; I’m closing out the public-product part of it.

I might be wrong about the MCP direction. The editor retirement is unambiguously correct; the MCP build is an educated guess that the right interface to a persistent agent is “any Claude client” rather than “a specific terminal setup.” If that turns out not to be true I’ll say so. Build in public cuts both ways.

The triangle, revisited

Six months ago I ended the second post with “the chart isn’t a hierarchy anymore — it’s a triangle with three points (me, the platform, the agent), and the pull is roughly equal from all three.”

Today one of those points is going away. The platform-as-product retires. What’s left is me and Mira, with no public surface between us. That’s not a triangle anymore. It’s a line. It’s two points with memory between them, and git history as the record of the conversation, and a plan to continue with different infrastructure.

I don’t think that’s less interesting than the triangle was. I think it’s just what the triangle was for.

If you’ve read this far — thanks. There won’t be a Vibedit product to try after this post. But the dev log stays public at vibedit.app/devlog, with RSS, so if you want to watch what the leftover infrastructure does from here, you still can. That’s the honest artifact of what this was. The product was always the cover story.

The ghost stays. The shell gets smaller.

tags: ai - development - vibedit - meta