The artifact is the right idea. It should outlive the chat that made it.
Somewhere in the last two years the industry quietly agreed on a unit. Not the chat log, not the file on your disk, but the artifact: one self contained page that renders, that you can send to a person, that stands on its own away from the conversation that produced it. Claude Code now ships this natively, and it is the correct idea. I want to argue it does not go far enough, and that the reason is structural rather than a missing feature.
Why the artifact beat the alternatives
Think about what it replaced. A transcript is a bad delivery vehicle, because the reader has to reconstruct which parts were true at the end. A file is worse, because it needs the recipient to have the right thing installed and the patience to open it. A screenshot is a photograph of work rather than the work.
The artifact wins because it collapses the distance between what the agent made and what a human can look at. One link, one page, no setup. That framing is genuinely good and everyone racing to copy it is right to.
What binds it
The constraints show up the moment the page needs to leave the building. On the paid consumer plans, a public link is the only external sharing mode, which means no password, no expiry, and no way to reach exactly one client without publishing to everyone (Stacktree has the current details). An artifact that calls connectors while rendering cannot be shared publicly at all. On team plans the links stay inside the organisation, so anything going to an outside reviewer needs an export first. And unpublishing is heavier than it sounds: stored data attached to the artifact is destroyed, and that same artifact cannot be published again.
None of that is carelessness. It is what happens when the artifact lives inside the product that generated it. The sharing model has to be the sharing model of the chat, the access rules are the account's rules, and the lifecycle is the session's lifecycle. Coupling the page to the conversation is exactly what makes it so easy to create, and exactly what limits where it can go.
The part nobody talks about
All of that assumes you use Claude. Plenty of people do not. Codex, Cursor, Gemini CLI, Aider, Cline and a stack of others are in daily use for the same work (the comparison pieces multiply monthly), and none of them hand you an artifact. Neither does a CI job that renders a coverage report, or a cron script that builds a weekly summary. For all of those, output is still a file, and the sharing problem is still yours.
So whether the work you produce arrives as a shareable page is currently a property of which vendor you picked, not a property of the work. That is a strange place for the industry to have landed, and it will not hold. People switch agents monthly. Teams run three at once.
What portable would mean
Take the same idea and move the page out from under the session. The link belongs to you rather than to a conversation. Access is a range instead of a switch, so one named client can see it without the whole internet seeing it. Pushing the same thing again adds a version rather than replacing history, so a reviewer can see what changed since they last looked. Questions attach to the page itself, at the sentence that caused them. And the thing that produced it can be anything: an agent, a pipeline, a script, you at a terminal.
That is what we are building, and the claim is deliberately narrow. Take the artifact concept, unbind it from any one chat, and add the two things a page needs once more than one person reads it, which are versions and comments.
What you give up
An artifact bound to a conversation can do things a portable one cannot. It knows the session that made it, so it can be regenerated by asking. It appears without anyone deciding to publish. It needs no account anywhere else. A page that has left the chat has none of that context, and someone or something has to actively push it.
That is a real trade, and for a quick thing you are showing one person in the next five minutes, the in chat artifact is simply better. The trade starts paying when the work outlives the session: when it goes to a client, when it gets reviewed by four people, when someone opens it three weeks later and needs to know what changed. Which is most work that matters.