CLI tool for Claude Code

Claude's last answer, in your clipboard.

Type cc and the most recent thing Claude Code said is copied. cc prompt grabs the question that started the conversation, cc convo the whole exchange, cc share a link to it. One Python file, no dependencies, and it still compiles your C.

Commands

Six subcommands. Three you'll use.

cc

Claude's most recent output. The final text reply of the last turn — no tool calls, no thinking, no mid-turn status. Alias: cc last.

cc prompt

The original prompt of the conversation, with <system-reminder> blocks stripped and slash commands flattened to /name args.

cc convo

The whole conversation: every prompt you typed and Claude's final reply to each. Ready to paste into an issue, a doc, or another model.

cc list

Recent sessions for this directory — id prefix, last activity, cwd, opening prompt — so you can pick one with -s.

cc info

Token usage, turn count, transcript path and the claude --resume command for the session — printed, not copied.

cc share

Uploads the conversation and copies its unlisted link; --live makes it a live window viewers can message. Every other copy does the upload too once a share token is configured — see Share a link.

$ cc
cc: copied Claude's last output — 1,204 chars via wl-copy
cc: session 72bc0bc2 · 14 turns · 147k context · 5.5M tokens total · claude --resume 72bc0bc2-114d-…
cc: https://cdn.softwaresoftware.dev/c/774132c6dbd6

$ cc prompt
cc: copied original prompt — 312 chars via wl-copy
cc: session 72bc0bc2 · 14 turns · 147k context · 5.5M tokens total · claude --resume 72bc0bc2-114d-…

$ cc convo
cc: copied conversation (14 turns) — 38,910 chars via wl-copy
cc: session 72bc0bc2 · 14 turns · 147k context · 5.5M tokens total · claude --resume 72bc0bc2-114d-…

$ cc list
72bc0bc2  2026-08-14 22:41  ~/projects/tools/cc            build the landing page for cc
9f31e0d7  2026-08-14 20:05  ~/projects/tools/cc            write cc — a tool that copies…

$ cc share
cc: https://cdn.softwaresoftware.dev/c/774132c6dbd6  (copied)

Which session

It picks the conversation you mean.

Inside Claude Code

Run ! cc from the prompt, or let Claude run it through the Bash tool, and it uses that exact session — CLAUDE_CODE_SESSION_ID is set, so there is nothing to guess.

From another terminal

Otherwise it takes the most recently active session whose working directory is your cwd or a parent of it. Sitting in the project you were just working in is enough.

Override it

-a ignores the directory. -s 72bc picks a session by id prefix. -n 2 takes the second most recent. -d PATH matches sessions for another directory.

Look before you copy

cc -p prints to stdout instead of copying, so you can pipe it. cc --paths shows which transcript file was used. -q drops the confirmation line.

Share a link

Every copy is also a link.

With a share token configured, each cc also uploads the conversation and prints an unlisted link such as https://cdn.softwaresoftware.dev/c/774132c6dbd6. Paste it into a chat, an issue, a review — whoever opens it reads the conversation, not a screenshot of it. Here's the live conversation that built this tool (it's live — say hi) →

What the viewer shows

Your prompts and Claude's final reply for each turn, by default. Toggles reveal mid-turn updates, tool calls (inputs and results, clipped to 4 KB each) and thinking, when the transcript records it. ?show=mid,tools,thinking in the URL pre-sets them.

One link per session

The link is stable for the session — re-running cc updates it in place rather than minting a new one. Share it once, keep working, and it stays current.

Opt out, or share less

--no-share skips the upload for one run. --minimal uploads only prompts and final replies, no tools or thinking. cc share just uploads and copies the link.

Bring your own server

Uploads need a token, so only people who hold one can publish. The server is server/cc_share.py in the repo — Python stdlib, no dependencies — and runs behind any reverse proxy; tokens live in ~/.cc-share/tokens.

Live windows

cc share --live (or live=1 in the config) turns the page into a live window on the session: it follows the transcript in real time and gains a message box. Viewers — or you, from your phone — can send messages straight into the running Claude Code session via session-bridge, and Claude's replies show up on the page. --chat-code CODE gates sending behind a code, senders are rate-limited, and only live shares accept messages; --no-live forces a static snapshot.

Install

One line. Python 3.8+ is the only requirement.

Installs to ~/.local/bin as cc and claude-copy. No pip, no venv, no packages.

Linux · macOS · WSL · Termux
curl -fsSL https://cc.softwaresoftware.dev/install.sh | sh
Windows PowerShell
irm https://cc.softwaresoftware.dev/install.ps1 | iex

Prefer to see what you're running? install.sh, install.ps1 and the script itself are plain text — read them first.

FAQ

The questions worth asking.

Doesn't cc shadow the C compiler?

Yes, on purpose — and harmlessly. Anything the tool doesn't recognize is exec'd to the next cc on your PATH, so cc foo.c -o foo, make and CMake all keep working. It only intercepts its own subcommands and flags. Want to be explicit in a build environment? Set CC=/usr/bin/cc. Want it gone? Use claude-copy and delete ~/.local/bin/cc.

How does it reach the clipboard?

It tries the backends in order and the first one that works wins: pbcopy on macOS; PowerShell Set-Clipboard or clip.exe on Windows and WSL; termux-clipboard-set on Android; wl-copy, xclip, xsel or KDE klipper over D-Bus on Linux; and OSC 52 when you're over SSH and the terminal supports it. The confirmation line tells you which one was used.

Where does the text come from?

Claude Code writes every session to ~/.claude/projects/<encoded-cwd>/<session-id>.jsonl ($CLAUDE_CONFIG_DIR is respected). cc walks those files by mtime, reads the cwd field, and parses the records: a prompt is a user record that isn't a tool result, meta, sidechain or compaction summary; a response is the last assistant message with a text block in that turn. Nothing is sent anywhere — it's all local files.

What does cc convo leave out?

Tool calls and results, extended thinking, and the mid-turn text Claude emits while it works. You get the prompt and the final reply for each turn — the part you'd actually forward to someone.

Who can see a shared link?

Anyone who has it. Links are unlisted — a random id, no index, no listing — but not private: there is no login on the viewer, so treat a share link like a pastebin URL. Publishing, on the other hand, needs a token: without one cc never uploads anything, and --no-share skips it for a single run even when you have one. A live share (--live) keeps publishing whatever happens in that session until you re-share it with --no-live. Nothing else leaves your machine — the transcript is read from local files.