Claude Code Artifacts: Ship Session Work as Live, Shareable Pages

The hardest thing you built this week lives in your terminal scrollback, and it dies when you close the tab. You walked Claude Code through a gnarly PR, watched it reason through the diff, confirmed what you tested. The reviewer who needs that context gets a Slack paste of raw text with no annotations. You traced where personal data flows across the codebase for a privacy review, and the output is a wall of file paths nobody else will read. You kept an incident timeline as Claude worked the outage, then the session ended and the timeline went with it.

This is the quiet tax on terminal-first work: the reasoning is the valuable part, and the reasoning is exactly what does not survive the session. Your teammates never see the context, only the conclusion. Every time you want someone else to understand what happened, you rebuild it by hand in a doc, a comment, a screenshot, a Loom. The work is done and you are still working.

Claude Code Artifacts close that gap. An artifact is a live, interactive web page that Claude Code publishes from your session to a private URL on claude.ai. You open it in a browser, it updates in place as the session continues, and you share it with a teammate from the page header. The reasoning stops being scrollback you have to translate. It becomes a page you send.

What a Claude Code Artifact Actually Is

An artifact is a capture of work, not an application. Claude builds the page from everything your session can reach: your codebase, the conversation itself, and any data it pulls through your connected MCP tools. That full-session context is the whole point. The page can show things that would take paragraphs to describe, because Claude already has the diff, the file tree, the tokens, and the relationships in working memory.

A few mechanics make it different from "Claude wrote an HTML file":

It is one self-contained page, served from claude.ai. Claude Code wraps the file in an HTML document shell and serves it under a strict Content Security Policy. No external requests, no backend, no second route. For multi-section content, Claude uses in-page anchors rather than separate files.

Every publish is a new version at the same URL. When Claude updates an artifact, the open page refreshes in place and anyone with it open sees the change the moment it lands. Each publish becomes a version, and from the Share control you choose which version viewers see. You can roll back to an earlier one at any time.

A gallery collects everything you have made. Your gallery at claude.ai/code/artifacts lists every artifact you have created, each with the title and tab icon Claude picked for it.

Here is the boundary worth internalizing early: an artifact has no backend. It cannot store form input, authenticate viewers itself, or call an API at view time. The published file must be .html, .htm, or .md, and the rendered page must come in at 16 MiB or smaller. If you need a hosted internal tool with a live backend, deploy that on your own infrastructure. An artifact is for showing finished thinking, not for running a service.

How to Create One

There is no slash command. You ask for it in plain language, the same way you ask for anything else. Name the feature or describe the visual output you want, and Claude either publishes an artifact on its own when the output suits a page, or builds one because you asked. The official docs give two starter prompts verbatim:

Make an artifact that walks through this PR with the diff annotated inline.

Build a dashboard artifact of last week's deploy failures by service and keep it updated as you investigate.

Claude writes the page to an HTML or Markdown file in your project, then asks permission before publishing the first time. The prompt reads something like Claude wants to publish "Deploy failures by service" (deploy-failures.html) to a private page on claude.ai. Approve it once and republishing the same artifact does not prompt again. Claude prints the URL and your browser opens to the page. Press Ctrl+] to reopen the most recent artifact from the terminal at any time.

Updating works the same way. Ask Claude to revise the page, or let a long-running task republish as it makes progress, and Claude edits the underlying file and publishes to the same URL. To update an artifact from a different session, hand Claude the artifact URL and ask it to revise. Without the URL, a new session always creates a new artifact instead of editing the old one.

Update https://claude.ai/code/artifact/5fbea6f3-... with today's numbers.

If you do not want the browser to open automatically on every publish, set CLAUDE_CODE_ARTIFACT_AUTO_OPEN=0 in your environment.

The Prompts That Map to Real Roles

The reason artifacts matter is that the same mechanic serves a dozen different jobs. Anthropic's announcement frames artifacts around concrete role-based prompts, and they read like a tour of who is stuck pasting context into docs today. These are the prompts as published:

Notice the pattern. Every one of these is output that is easier to look at than to read line by line, produced from context the session already holds. The SRE prompt is the sharpest example: "republish as I work through it" means the incident page fills in live while the outage is still active, so anyone with the link follows along without reading your terminal. That timeline pulls its error spike from your monitoring tool data, which is exactly the kind of live signal an artifact is built to surface.

Beyond the role prompts, the docs describe a handful of interaction patterns worth knowing. You can ask for several variants on one page to compare layouts or API shapes side by side. You can request sliders and toggles bound to a value you are tuning, like an easing curve, and watch it update live. You can even ask for a "Copy as prompt" button that turns your interaction with the page back into text you paste into the terminal, so a triage board you reorder on the page flows its final ordering back into the session.

Where Artifacts Pay Off for Teams

Solo, an artifact is a nicer way to look at output. On a team, it changes who can see your reasoning without you doing extra work.

A PR walkthrough is the obvious case. Instead of a reviewer reconstructing your intent from a description, you publish a page with the diff rendered, your reasoning in the margin, and findings color-coded by severity. The reviewer reads your thinking next to the code. This is the lightweight, single-session cousin of a full multi-agent code review, where several agents analyze a PR in parallel. An artifact captures and shares the result of that analysis as a page anyone on the team can open.

Incident timelines are the other standout. During an outage, the on-call engineer keeps a single page current: timeline, suspect commits, the error spike from monitoring. Everyone watching the incident reads the same live page instead of pinging for status. When the incident closes, the timeline is already written, already shareable, already a postmortem draft.

Then there is the engineering manager's weekly summary, built from the PRs that merged, grouped by project. No more assembling a status update by hand on Friday. The same goes for architecture maps that new hires can actually read, license audits legal can review, and data-flow maps a privacy team can sign off on. In every case the artifact is the deliverable, not a thing you build after the deliverable.

Artifacts also pair naturally with the kind of parallel, multi-session work that an agent dashboard coordinates. When several sessions are running at once, each can publish its own artifact, and the gallery becomes a shared surface for the team to see what every session produced.

Privacy, Access, and Admin Controls

This is where the design is deliberately conservative, and it matters for anyone evaluating artifacts inside a company.

Private by default. A new artifact is visible only to you. You open it, then use the Share control in the page header to grant access to specific people in your organization or to everyone in it. The header names you as the author, so anyone you share with can see who published the page.

Sharing stops at your organization. Viewers must sign in to claude.ai as a member of the same organization that published the artifact. There is no option to make an artifact viewable outside it, and no public link. If you need to send the content to someone outside the org, ask Claude for the underlying HTML file and share that file directly. Artifacts are also viewable, not co-edited: people you share with see each version you publish but cannot change the page. You remain the only writer.

For admins, the controls live in claude.ai admin settings:

• Org-level toggle. Turn artifacts on or off for the whole organization under Settings > Claude Code > Capabilities. On Enterprise plans with role-based access control, you can scope artifacts to specific roles under Settings > Roles.
• Retention policies. Under Settings > Data & privacy controls, set how long artifacts are kept before automatic deletion, with separate retention periods for artifacts still private to their author versus artifacts that have been shared.
• Audit log. Publishing, sharing, and deleting each appear under the claude_artifact_* event types.
• Compliance API. Endpoints to list an organization's artifacts, retrieve a specific version's content, and delete an artifact, for org-wide visibility and cleanup.

Artifact content is stored on Anthropic-operated infrastructure and is visible only to authenticated members of the publishing organization. If your org restricts outbound network access, note that the viewer loads each artifact from a sandboxed *.claudeusercontent.com origin, so that domain needs to be allowlisted alongside claude.ai.

Availability and How to Get Access

Artifacts are in beta, and access depends on every condition below being met. When one is not, Claude writes a local HTML file or says it cannot publish.

Pages are viewable in any browser once published, even though you create them from the CLI or desktop app. If you want to turn artifacts off for your own sessions regardless of the org setting, you have three options: set "disableArtifact": true in your settings file, set CLAUDE_CODE_DISABLE_ARTIFACT=1 in your environment, or add Artifact to permissions.deny.

One practical caveat on cost: generating an artifact uses output tokens like any response, and a styled page is more token-intensive than the same content as terminal text. Inline CSS, interactive JavaScript, and especially images embedded as data URIs are the main drivers. Prefer SVG or HTML and CSS over raster images for diagrams, skip interactivity you do not need, and have the page summarize large datasets rather than inline them in full.

Where Artifacts Fit Among Claude's Shareable Outputs

Artifacts are not the first time Anthropic has shipped a cloud-hosted, browser-reviewable output from a Claude Code session. They are the third move in a clear pattern.

Ultraplan offloads a planning task to the cloud and gives you a browser review UI with inline comments to refine the plan before it executes. Claude Design builds a prototype on a shared canvas and hands it to Claude Code as a structured spec. Artifacts complete the set on the output side: they take work the session already did and publish it as a page a teammate can open.

The throughline is that the terminal is no longer the only surface. Planning, design, and now session output each get a browser-native, shareable form. For teams that already run structured multi-agent workflows, this is the missing export step. The kind of agent team pipelines the Code Kit systematizes produce rich session reasoning, and artifacts are how that reasoning leaves the terminal and reaches the people who need it without a manual translation pass.

That is the real shift. The valuable part of a Claude Code session has always been the reasoning, and the reasoning has always been the part that did not survive. Artifacts make it a page. Ask your session for one the next time you finish something worth showing, and watch how much less time you spend explaining it afterward.

New to working in the terminal? Start with the terminal-first development model to understand how Claude Code's execution surface works, then see Ultraplan and Claude Design for the other half of Anthropic's cloud-hosted, shareable output story.