AI 生成物是新一代應用程式，管理得最好的人勝出

Ask an AI to make you something and you get an artifact. A dashboard, a doc, a tracker, a small tool. It's impressive, and then it's gone. The next chat has no idea it exists.

Every morning I open a fresh Claude session and it's a genius with amnesia. It can build a dashboard, refactor a service or write a report in minutes. It has no idea what we built yesterday.

I think that small annoyance is the most important unsolved problem in software right now. Not the models. Not the apps. What happens to the things the models make.

One artifact is a toy

I'm building landed, a job search product, mostly on my own, with a lot of help from Claude. Along the way I ended up with a set of internal tools that nobody else uses:

• a content calendar for every channel we post on;
• sixteen weekly reviews, one for each part of the company;
• a lab that tests and watches the AI agents inside our product;
• a tool for making videos;
• a sprint board and a weekly checkout.

Every one of them started as an artifact. A page Claude made in one chat. What turned them into software I rely on every day wasn't better UI. It was management: somewhere for the data to live, a way for the agent to update it, a view for me, and a note telling the next session how it works.

Social, our content calendar. Claude drafts, makes the visuals and schedules. I mostly look. Numbers blurred.

Here's the strange part. I almost never type into any of them.

I don't open the calendar to add a post. I say "plan next week around the jobs report", and the calendar fills in. I don't add tasks to the sprint board. I tell Claude what I'm working on and it updates the board through a small command-line tool. In the video tool, the main input isn't a form at all. It's a box that says "Message Claude".

Vids, where we make videos. The main input is a message to Claude.

Chat is the input. The app is just the view.

That's when I realised personal software isn't a new kind of app. It's a collection of artifacts, managed well.

Building is cheap now. That's the point.

For most of the history of software, building was the expensive part. So one company built a project tracker for millions of people, and everyone bent their work to fit its fields, its views and its workflow. SaaS was built for everyone, so everyone got the average.

That constraint is gone. Any good model will write you a working dashboard in minutes, with exactly your fields. When I want a new column, I don't file a feature request. I say "add a column for which repo this touches", and it's there.

If building were still the bottleneck, every person with Claude would already have perfect software. They don't. Most people who've tried this have a folder of beautiful one-offs they never opened twice.

The bottleneck moved. It's now everything that happens after the artifact is made.

Four ways artifacts die

They forget. The artifact lives in one chat. Tomorrow's session starts from zero and spends half its context rediscovering what you built. Count how much of each session goes to re-explaining: where the board is, what we decided about pricing, which dashboard tracks signups, what broke last week. Agents are cheap enough now that the work isn't the expensive part. The context is.

They're alone. The useful things happen between artifacts. My weekly review notices that signups dropped. It raises a task. The task becomes a pull request. Next week the review checks whether signups came back, against the number it predicted. Four artifacts, one chain. That chain only exists because they can see each other. Most artifacts can't.

DNA: each task an AI raises carries its own prediction and links to the PR that shipped it. Numbers blurred.

They can't be trusted. When an agent changes something at 2am, you need to know which session did it and why, and be able to undo it. Without that record, you stop letting agents touch anything that matters, and they go back to being toys.

They don't run. Real tools need schedules. A weekly review that only runs when you remember to open a chat isn't a tool, it's a chore. And when a scheduled run fails, something has to turn red, or you find out a month later.

Fix those four and artifacts compound. Every session builds on the last. Leave them broken and you get a pile of impressive demos.

What good management looks like

From running my own setup for a few months, every artifact that survives has the same five parts:

1. Data that outlives the session, in a database or plain files, never a chat log.
2. A way for the agent to write to it, like a small CLI or API, so it isn't editing raw files and guessing.
3. A view for you, on the web, a desktop app or your phone.
4. A skill file, so any future session knows what the artifact is and how to use it.
5. A schedule, so it can run on its own and show red when it fails.

DNA, our metrics dashboard. It started as an artifact. Now an AI reviews it every week. Numbers blurred.

And then two things that no single artifact can do for itself, because no single artifact owns all of your work:

• Links between artifacts, so a review can raise a task, a task can point at a pull request, and a pull request can be checked next week.
• A record of who did what, so every row knows which session wrote it and why, and anything an agent did can be undone.

A weekly report written by the agent, in plain language, on top of the dashboard. Numbers blurred.

None of this is glamorous. It's filing, labelling, permissions and cron jobs. That's exactly why it's where the value is: the model makes the thing, and the management decides whether the thing is still useful in a month.

The same idea, applied to agents

It isn't only my own tools. Our product has AI agents in it, and I needed the same thing for them: one place where every run, every cost, every failure and every eval lives, so the next change to a prompt can be checked against the last one.

Agent Lab: cost, conversations and failures for our product agents. Numbers blurred.

Same five parts. Data outside the chat, a CLI the agent can use, a view for me, a skill file, a schedule. Once that existed, prompt changes stopped being vibes. They became experiments with a before and after.

The race nobody is talking about

So when people ask whether OpenAI or Anthropic or someone else "wins", I think they're watching the wrong race. Models are converging. They get cheaper and easier to swap every few months.

The interesting race is who manages artifacts best.

There are really three ways it can go.

The model company manages them. Claude is clearly moving this way: skills, artifacts that can keep their own data, scheduled tasks, connectors to your other apps, plugins, projects with shared context. Put those together and it looks less like a chat window and more like an operating system for your work. What it doesn't do well yet is the management itself. Most artifacts still live in one conversation, and the next session can't find them, link them or build on them. If Claude fixes that, it becomes the default home for personal software, and most people will never look further. Convenience usually wins. Most people keep their photos in iCloud, not on a home server.

You manage them, and the agent is a guest. Your artifacts live in your own files and database, on your machine or your domain, organised so any agent can find and use them. Claude today, something else next year. The case for this is also strong. The most valuable thing in the whole system is the history: your tasks, decisions, metrics and the links between them. That's exactly the thing you'd least want locked inside one company's product, and it's the hardest thing to move.

Both, and the artifacts don't care. Artifacts become a format, the way websites did, and run on whichever base you pick. This is the version I'd most like to see, and the least likely to happen without someone pushing for it.

My bet

I think the agent and the base will separate, the way the browser and the operating system did. The agent should feel like a very good employee who works inside your company, not a landlord whose building your company lives in.

But I hold this loosely. If Claude makes artifact management good enough, most people will never think about who owns the base, the same way most people never think about where their email is stored.

So I'm building the version I'd want: a local, agent-agnostic base where artifacts live, link and run, with recipes on top. It's called plinth.

plinth.b100x.ai

Either way, the winner is whoever solves the boring part. Not the model. Not the app. The management.

If you've built tools like these for yourself, I'd love to see them. And I'd love to hear where you land: will your personal software live inside Claude, or will Claude live inside your personal software?

I'm also building landed, which finds jobs that fit you and applies to them early. Most of the tools in this post were built to run it.