Claude Code Artifacts: Turn Any Coding Session Into a Live, Shareable Page

For two years, the output of a Claude Code session lived in three places: your terminal, your editor, and a CLAUDE.md file if you were organized. Your teammates had no window into what was happening unless you wrote it up afterward. Claude Code Artifacts, launched June 18, change that completely. A single command publishes a live, interactive web page built from your full session — codebase, conversation, and any connected tools — shareable with every authenticated member of your org.

The page is not a static export. It updates in place as your session progresses. A teammate watching the link sees the same evolving page you're driving from the terminal. When you close the session, the artifact becomes a permanent, versioned record at the same URL.

What changed on June 18

Artifacts launched in beta on June 18, 2026, for Claude Team and Enterprise subscribers. You need CLI version 1.13576.0 or later (or the matching desktop app release). The feature is off by default and enabled per-org by admins — no data leaves until you explicitly publish.

How Artifacts actually work

When you run /artifact inside a Claude Code session, Claude builds a structured web page from everything it knows: the files it has read, the changes it has made, the conversation so far, and any MCP connectors attached to the session. It does not just copy terminal output into a page — it synthesizes context the way a senior engineer would write up a handoff.

# publish an artifact from the current session
/artifact

# publish with a specific title
/artifact "Auth refactor — June 26 review"

# list all artifacts you've published
/artifacts list

# open a specific artifact in your browser
/artifacts open <artifact-id>

After publishing, you get a permanent URL scoped to your org. Every teammate with org access can open it. When Claude updates the artifact — either because you run /artifact again or because the session continues and Claude auto-publishes a new version — the open page refreshes in place. No reload required.

Five artifact types worth knowing

Artifacts are not templated — Claude generates the page from session context — but five patterns have emerged in the beta as the highest-value use cases.

1. PR walkthrough

Ask Claude to review a diff, then publish an artifact. The page shows the changed files, the reasoning behind each change, test results if available, and any open questions Claude flagged. Reviewers can read the walkthrough before touching the diff. Cuts first-pass review feedback loops significantly in early beta testing.

2. Incident page

Start an investigation in Claude Code, attach your monitoring MCP server, and publish. The artifact becomes the single-pane view: the failing test, the error spike pulled from the connected tool, and Claude's current hypothesis. Teammates join the investigation by opening the URL, not by asking you to context-switch into Slack.

3. System explainer

Ask Claude to map an unfamiliar service — reads the codebase, traces the call graph, identifies external dependencies — then publish. Onboarding engineers get a living explainer that updates as the code changes, not a stale wiki page.

4. Release checklist

Generate a release checklist from your CLAUDE.md and the current branch state, then publish. The checklist artifact auto-updates as Claude checks items off. The whole team watches the deploy checklist tick down in their browser.

5. Security or license audit

Run a security or dependency audit through Claude, then publish. The artifact links findings directly to the relevant code lines with full session context — not a raw SARIF file, but a structured report a non-engineer can read and route to the right team.

Real-time updates and version history

Every time Claude publishes an updated artifact, a new version is created at the same permanent URL. The page in any open browser tab refreshes in place — there is no separate "refresh to see changes" step. Teammates always see the latest state without any action on their end.

# Claude auto-publishes when significant work completes
# You can also manually trigger an update mid-session:
/artifact update

# View version history for an artifact
/artifacts history <artifact-id>

# Restore a previous version
/artifacts restore <artifact-id> --version <n>

The gallery at /artifacts list shows every artifact you've published, with version counts and last-updated timestamps. Admins see an org-wide gallery filtered by author, project, or date. Version history is indefinite in the beta — no retention limits are documented yet, though Anthropic's compliance API lets admins configure retention policies per org.

Privacy, org sharing, and compliance

Every artifact is private to its author by default. Publishing does not make it public — it makes it visible to authenticated members of your org and nobody else. There is no "make public" toggle in the June 18 beta. Anthropic has been explicit: artifacts are org-scoped and cannot be shared outside.

Admins get three controls worth knowing:

1. Role-based scoping: limit artifact visibility to specific roles (for example, only engineers can see security audit artifacts).
2. Retention policy: set how long artifact versions are stored before deletion. The compliance API exposes this to external audit tooling.
3. Org-level toggle: artifacts is disabled at the org level until an admin enables it, so no data is published accidentally on day one.

The incident-to-postmortem workflow

The workflow that most clearly shows the power of Artifacts is incident response. Here's how a real incident runbook looks with Artifacts wired in.

# 1. Start the investigation
claude "We have a 500 spike on /api/payments. Investigate."

# 2. Attach your monitoring MCP so Claude can pull real data
# (assumes you've already configured the MCP server)
# Claude reads logs, traces, and error rates automatically

# 3. Publish initial findings as the first artifact version
/artifact "Incident — payments 500 spike — June 26 14:30 UTC"

# 4. Share the URL with on-call teammates via Slack
# They open the link and watch Claude's investigation in real time

# 5. As Claude identifies root cause, it updates the artifact
# Every open browser tab refreshes automatically

# 6. When resolved, run a final publish
/artifact update "Incident resolved — RCA complete"

# The artifact is now the postmortem.
# Same URL, version history preserved, ready to link in Jira.

The incident page becomes the postmortem automatically. When the investigation closes, the artifact is already a versioned record of every hypothesis, every data point Claude pulled, and the final root-cause analysis. You don't write the postmortem after the fact — it wrote itself as you worked.

This same pattern applies to PR review (artifact → review link in the PR description), security audits (artifact → linked from the Jira ticket), and onboarding explainers (artifact → linked in the team wiki). The session becomes the document. The document stays alive.

If you're on a Claude Team or Enterprise plan and running CLI 1.13576.0+, enable Artifacts in your org settings and run /artifact at the end of your next investigation. The first time a teammate opens the link and sees the page update in real time is when the pattern clicks.

# update claude code to access artifacts
npm install -g @anthropic-ai/claude-code@latest

# verify your version
claude --version

# enable in org settings (admin only)
# Settings → Features → Artifacts → Enable for org

# then from any session:
/artifact

For related work on getting the most out of Claude Code sessions, see our guides on Claude Code Hooks (lifecycle events that can auto-trigger artifact publication) and subagents (multi-agent sessions that each publish their own artifact for fan-out work).