Claude Code Can Now Ship Your Session as a Live Page

There's a problem that comes up every time I work on something substantial with Claude Code: the session itself is invisible to anyone else. The codebase changes are visible via git. The conversation context, the reasoning, the live tool calls, the MCP data Claude just pulled from Stripe or PostHog? That all evaporates the moment the session ends or I share a diff.

I've been copying things into Notion and Slack for years. That workflow is lossy. You get a static snapshot of what you thought was important, written by you, stripped of the actual chain of reasoning. Anyone reading it is one step removed from the real work.

Anthropic shipped something in beta that addresses this directly: Claude Code Artifacts. The announcement describes them as live, shareable web pages built from your session's full context. That framing is worth unpacking.

What "built from session context" actually means

When you surface an Artifact in a Claude Code session, it doesn't just export your last message. It draws from the whole session: the codebase state, the conversation, and any MCP connector data Claude has pulled in. If Claude was reading from Stripe to show your seat counts, that context is available to the Artifact. If it was analyzing a bug across multiple files, the Artifact surfaces that reasoning as a page, not a transcript.

The resulting page is HTML. It opens in any browser. It refreshes as the session continues. And it lives at a shareable URL inside your org.

The key thing is where the page lives: inside your org, not the public internet. This is intentional. You're not accidentally publishing your codebase context to search engines. You're sharing it with the people inside your Anthropic org who have access.

The use cases I actually care about

Client-facing progress pages. If you're building something for a client, you can surface an Artifact that shows what Claude found, what it changed, and why. The client sees the reasoning, not just the commit. This is a different quality of handoff than a Loom or a Notion update.

Spec verification. You've described a feature to Claude, it's interpreted the spec, written the code, and run the tests. Before you ship, you can surface an Artifact showing the full interpretation chain. A teammate can read it and catch the misread before it becomes a bug.

One-session dashboards. If Claude pulled Stripe, PostHog, and Vercel data in a single session to diagnose a funnel problem, an Artifact can render that as a coherent dashboard. The alternative is manually assembling those views yourself. The Artifact holds the assembled version while the session is live.

Incident post-mortems. Claude diagnoses a production issue, traces it through logs, identifies the root cause. Surface an Artifact and you now have a post-mortem that wrote itself, rooted in the actual diagnostic session rather than a reconstruction from memory.

The current limitations (be specific)

This is a beta feature. If you're not on a Team or Enterprise plan, you don't have it yet. And even if you are, the sharing is org-scoped only. You can't surface a public Artifact link and send it to a client who isn't in your Anthropic org. That's a meaningful constraint for solo builders working with external stakeholders.

The feature is available from both the Claude Code CLI and the desktop app. So you don't need to change your workflow to try it. You just surface the Artifact when you want it.

I haven't had a client-facing use of this yet. My team is small enough that most context transfer is already direct. But I can see the value clearly for anyone doing contract or agency work, where the "show your work" demand is real and the session context is currently evaporating after every session.

Why the model shift matters

There's a pattern in how agentic tools evolve: the output starts as code, then becomes a diff, then becomes a deployed system, and eventually the session itself becomes a deliverable. Artifacts are that last step applied to Claude Code.

The output of a Claude Code session isn't just what Claude wrote. It's the reasoning chain, the data it pulled, the decisions it made, and the code it produced. If you're running Claude across MCP connectors, that session is essentially a live analytical environment. Artifacts let you surface that environment as a page, not just export it as text.

For solo operators, the immediate value is internal. You can resurface a session's findings without reconstructing them from git history and Slack threads. For small teams, the value is the handoff quality. The person picking up your work reads what Claude actually understood, not your summary of what Claude did.

The org-only constraint is the right call right now. Session context can include sensitive data from MCP connectors. Publishing that publicly by accident would be a serious problem. The beta period is the right time to tighten the sharing model before expanding it.

Artifacts are in beta for Team and Enterprise orgs. If you're on one of those plans, it's available now from the CLI or the desktop app. Worth trying while the feature is still being shaped, and while feedback from early users has a real chance of landing in the final design.