How do I take a Claude project public and publish

Making a Claude project publicly available usually means two things at once: (1) taking the content created during a Claude Web / Claude Projects session (chat transcripts, artifacts, docs, UI “Projects”) and exporting or sharing it, and (2) taking code generated or scaffolded by Claude Code and packaging it so other people (or production systems) can consume and run it. This article walks you through both workflows in practical, step-by-step detail, with safety, provenance, and best-practice recommendations woven in.

What follows is an operational, end-to-end walk-through: how to export and publish Projects created in Claude Web, and how to package, review, and publish code generated with Claude Code.

Key short takeaway: publish artifacts and projects from Claude Web using the built-in Publish / Share flows (you can also embed artifacts or copy a public link), and export/save Claude Code conversations (using the /export command and the files under ~/.claude/projects/) then package them into a normal code repo or release (GitHub, npm/PyPI/Docker, or a hosted web app).

What are matters for publishing Claude projects

In the last two years Anthropic has been maturing the Claude product line with features that matter for publishing and sharing:

• Claude Projects (the Projects UI on Claude.ai) lets Pro and Team users organize chats into Projects and make selected chats/artifacts viewable by teammates — a key building block for sharing a project internally and preparing it for public exposure. ([anthropic.com][1])
• Anthropic released Claude Code, a terminal/IDE-centric, agentic coding tool and companion CLI/IDE integrations (VS Code, JetBrains) that produces code artifacts and can be integrated into developer toolchains. There’s also public documentation and best-practice guidance for using Claude Code in real projects. ([claude.com][2])
• Claude’s support materials include explicit user data export flows from the web UI (Settings → Privacy → Export) that are relevant to backing up or migrating project data before publishing. For Team plan Primary Owners there are export controls as well.

What follows is an operational, end-to-end walk-through: how to export and publish Projects created in Claude Web, and how to package, review, and publish code generated with Claude Code.

How do I publish/export a project created in Claude Web (step-by-step)?

Claude Web exposes two complementary ways to make outputs public: Publish Artifacts (single outputs: diagrams, documents, charts) and Share Projects (project-level visibility, teammate access). The following step-by-step covers both flows and how to embed or download.

Step 1 — Prepare the artifact(s) in Claude Web

1. In Claude Web, collect the chats or the artifact (document, diagram, flowchart, image) you want to publish into a Project or stand-alone Artifact.
2. Clean and annotate: edit the content so it reads well, add captions, and add any missing attribution.

Step 2 — Publish the Artifact (single output)

1. Open the artifact in Claude Web.
2. Click the Publish button (this action toggles the artifact to “public” and makes a public URL available).
3. After publishing, click Get embed code if you want to embed the artifact into a site or CMS — copy the generated HTML snippet. (Embedding is supported on free/Pro/Max plans.)

Notes & tips

• You can also download certain artifact types (SVG, PNG, Mermaid text, or other export formats) from the UI — use the download to include the artifact in your repo or blog post.
• Add an explanatory caption and alt text to the embedded content for accessibility.

Step 3 — Share the Project (broader collection with permissions)

1. Open the Project list in Claude Web.
2. Next to the project name, click Share.
3. In the Share dialog you can:
   • Add individual members or teammates via email/name.
   • Set permission levels (Can view / Can edit). For public releases, choose to Make project public (if available) or publish key artifacts individually.

Step 4 — Publish the project artifacts externally

• Publish a blog post / release note. Include the public URL or embedded artifact, plus a short note about what Claude generated vs. what humans reviewed.
• Create an accessible archive. Add a link to a ZIP file or export bundle (see packaging Claude Code below) for reproducibility.

How do I export and package the transcripts or code generated by Claude Code?

Claude Code is agentic and primarily CLI-driven; it saves sessions locally and provides slash commands (including /export) to save and export conversations. The recommended workflow is: export the conversation + supporting files, convert/clean the output into a human-friendly format, add a code repo with metadata, then publish. Below are practical, reproducible steps using the built-in command and common packaging tools.

Step 1 — Make sure Claude Code is set up correctly

• Install Claude Code and configure (follow the official setup guide: connect via the Claude Console or set up billing if needed).
• Verify you can run claude in your terminal and that you have a workspace.

Step 2 — Export the conversation(s)

1. In the Claude Code REPL (interactive CLI), run: /export myproject-conversation.jsonl or simply /export which will copy the conversation to clipboard or write a file (behavior depends on the version and flags). The /export command exports the current session to a file or the clipboard.
2. If you prefer to gather all project sessions, inspect the ~/.claude/projects/ directory (Claude Code persists conversations there as JSONL or JSON files). Example: ls -la ~/.claude/projects/
3. If the export is JSONL, convert to Markdown for readability:
   • Simple Python snippet: import json out = [] with open('myproject-conversation.jsonl') as f: for line in f: out.append(json.loads(line)) # transform out -> markdown file
   • Or use community tools such as claude-conversation-extractor or claude-code-exporter (community projects exist that parse and convert sessions to Markdown/MDX).

Step 3 — Create a reproducible repo

1. Create a local repo: mkdir my-claude-project cd my-claude-project git init
2. Add:
   • README.md — project description, provenance notes, usage instructions.
   • CLAUDE.md — how Claude was used (prompts, temperature/parameters if relevant, what was human-edited).
   • LICENSE — chosen license.
   • artifacts/ — include downloaded artifacts (images, SVGs) and the exported conversation files (.jsonl or .md).
   • src/ — generated code (if any) and supporting scripts.
3. Commit: git add . git commit -m "Initial Claude project export and artifact bundle"

Step 4 — Package the code for distribution

Which packaging path you choose depends on the code language and target audience.

If it’s a JavaScript/Node package:

• npm init → fill metadata.
• Add index.js, tests, and an examples/ folder.
• Publish to npm: npm publish --access public (Use --access public for scoped packages you want public.)

If it’s a Python package:

• Add pyproject.toml or setup.py.
• Build wheel and sdist: python -m build twine upload dist/*

If it’s a web app or demo:

• Create a small web front-end (e.g., Vite/Next/Vercel).
• Deploy to Vercel/Netlify:
  • Connect GitHub repo.
  • Add environment variables with non-sensitive keys (none for public demo).
  • Deploy.

If it’s a containerized service:

• Add Dockerfile.
• Build & push: docker build -t dockerhubuser/my-claude-demo:1.0 . docker push dockerhubuser/my-claude-demo:1.0

Step 5 — Create a release and documentation

• On GitHub: open the repository → create a Release (tag v1.0.0) and upload compiled artifacts (ZIP, tarball).
• Add a CONTRIBUTING.md and SECURITY.md describing how to report issues or sensitive data leaks.
• Add a short demo page (GitHub Pages) with the embedded artifact URL from Claude Web or downloadable assets.

How do I integrate the Claude Code export into CI/CD for automated publishing?

Example: GitHub Actions to export, convert and release

1. Goal: when a branch is pushed, export the latest Claude conversation files (if you have them in a machine/CI artifact or via an MCP server) and create a release.
2. High-level steps:
   • Use a workflow (.github/workflows/publish.yml) that:
     • Checks out the repo.
     • Runs a small script to convert JSONL → Markdown.
     • Uses actions/create-release to publish the release.
     • Uploads the artifact.
3. Security note: Don’t store private API keys in the repo; use GitHub Secrets and rotate tokens.

(Community tools such as claude-code-exporter and MCP-compatible servers make integrating conversation export into server flows simpler; look for MCP/CLI integrations that stream conversations to a centralized archive).

What about collaborative sharing and reproducibility — how do I let others run the same workflow?

Make a reproducible environment

• Add environment.yml / requirements.txt / package.json listing exact versions.
• Add a Makefile with targets: make export make convert make build make release
• Document the exact Claude Code version used (e.g., claude-code v1.0.44) and the export command. This helps readers reproduce exports (versions change behavior of /export).

Share the conversation + code

• Publish the Claude artifact (public ULR/embed) and link to the GitHub release that contains the exported transcripts and packaged code.
• Add a one-click demo (Vercel / GitHub Pages) and include a Try it link.