claude-code-widgets

The 2048 sliding-tile puzzle; it plays itself until you take the keys.

Ask a yes or no question and get an answer of doubtful reliability.

The most recent tool calls with how long each took and whether it failed.

Where a command lands outside this folder: the kube context, cloud profile, Terraform workspace or database it is aimed at, named in the permission dialog

What changed in the system prompt and the built-in tool descriptions Claude Code gives Claude since the version you last ran, with the before and after one command away

An aquarium with a fish for every running tool call and agent.

Ask a side question about the conversation, even mid-turn, and get the answer on a card without adding a turn to the transcript

Counts which tools Claude calls in this project, puts the unused ones behind ToolSearch, lists the daily ones up front, and reports how many schema tokens each request no longer carries

Achievements earned across sessions, such as twenty tool calls in a row without a failure.

A status board Claude keeps itself: its current goal, key findings and open questions, pinned through a tool the plugin registers.

A boss fight against the context window: its health drops as context fills, and compaction defeats it.

A brick breaker that plays itself; every tool call adds a row of bricks.

A campfire that burns higher the busier the session is and dies down to embers when idle.

The files edited this session, with how many edits each took.

The latest test, lint and build runs: whether each passed, how long it took and how long ago.

Your local time beside the time zones you pick.

A coffee cup that empties as you work and nudges you to take a break when it runs dry.

Stops an edit to a file another Claude Code session on this machine changed since this one last read it, and has Claude read it again first

The commits made since the session started.

A night sky that gains a star each turn and joins them into a named constellation.

The context window as a stacked bar, one colour per /context category, with six view modes.

A countdown to a deadline you set, with a toast when it arrives.

A second pair of eyes: a separate model reads the uncommitted diff and lists only real defects, which you can hand to Claude

Looks up every package Claude installs on npm or PyPI before the command runs, and holds the install for a yes when the name is missing or under 30 days old

The last edit as a syntax-highlighted diff.

A definition of done you write once: Claude ticks each item with evidence through its tick tool, and is pulled up when it says done with items open

The spinning 3D donut, drawn in pixels; it spins faster while tool calls are running.

Every running subagent with the tool it is on and its last sentence, and /whisper slips one of them a note without stopping the turn

Whether Claude has got the message you typed while it was working: how late a request first carried it, and what Claude changed before it heard you

Level meters that jump with every tool call and fall back to rest.

The Widget Factory floor: each work order with its station and holder, what has shipped and what was turned back

A file tree of the project directory with expandable folders.

A night sky that sets off fireworks when a test, lint or build run passes.

Checks every file path, cited line and code symbol in Claude's last reply against the working tree, with no model call, and flags the ones that are not there

Context growth per turn as a chart, with a prediction of how many turns are left before compaction.

A one-line fortune for the turn, drawn fresh each time you send a prompt.

A plant that grows a leaf per tool call, flowers when checks pass and wilts when a call fails.

The current branch, how far it is ahead or behind, what is staged or changed, and the last commit.

What changed in the working tree since each test, lint or build command last passed, measured against a hidden git snapshot taken at that moment and handed to Claude on request

A tally of this session's permission checks: what was allowed, what you were asked about and what was denied.

Every failing check sends in an invader; every passing check shoots one down.

A numbered table of contents for the session, built as it happens from prompts, first edits, checks turning red or green, commits and questions; press a line to scroll the transcript to it

What a project has cost across every session, from any folder or worktree in it: measured as each turn ends, and read back from the sessions Claude Code saved

Conway's Game of Life; every tool call drops a glider.

Select a hash, path, name, timestamp or colour in the transcript with the mouse and the card says what it is, with no model call

A pixel map of the repository: every tracked file a block, lit blue where Claude has read and green where it has edited.

Mark passages of Claude's reply with the mouse, write a remark against each, and send them back as one quoted prompt

An LED ticker that scrolls session events across the card: turns, tool calls and failures.

A first-person walk through a maze seeded by the project folder, drawn with a raycaster.

Minesweeper, played with the mouse in the fullscreen layout.

The real moon right now, drawn for your hemisphere, with a countdown to the next full moon and what it means for your deploy

A mosaic that gains one tile per tool call, coloured by tool, until the session is a picture.

Gives Claude a jot tool for writing down what its future self should know about this project, and reads the notes back next session

Pinned notes that stay on screen and survive restarts; add one with /note.

A small solar system whose planets speed up while tool calls are running.

When a push or install fails on the network, checks the provider's status page and says whether GitHub, npm, PyPI or crates.io reports an incident

The file, edit or command Claude is writing right now, drawn line by line as the tool call's arguments stream in, before the tool runs

Clawd, a pixel crab whose mood follows the session.

The pipes screensaver: coloured pipes grow across the card while the session is idle.

A focus timer: 25 minutes of work, a 5 minute break, and a count of the sessions finished.

Quotes thinking-summary sentences that name a gap and a choice made anyway, unless the reply flags it, and starts your correction; no model call; needs "showThinkingSummaries": true in settings.json

The conversation behind a line of code: for lines Claude is about to edit, or a path:line you ask about, the prompt you typed before they were written and the command that resumes that session

The session as a dungeon crawl: every turn is a room, tool calls are monsters, failures wound you and passing checks drop loot. Your hero carries over between sessions.

A queue of prompts that run back to back while you are away, a gate command each must pass before the next starts, and a report of how each one ended

A race track for parallel subagents: each advances one stride per tool call, with a podium as they finish.

Falling code rain that speeds up while tool calls are running.

Replaces API keys, tokens, private keys and passwords in command output and file reads before Claude sees them

Which of the commands and edits Claude has made in this project would stop for permission or be refused right now, asked of the engine's own permission check without running anything

The pictures Claude looked at this session, image files it read and screenshots that came back from tools, drawn as Claude received them and opened full size with one command

The other Claude Code sessions open on this machine: folder, branch, and whether each is busy.

A compaction that keeps every word you and Claude said and folds only the old tool traffic, with no summary and no tokens spent

A unique pixel emblem generated from each session's activity, kept in a gallery across sessions.

The caveats in Claude's replies that left your screen while Claude was still writing and have not been back, quoted in full; it never claims that what was on screen was read

A pixel skyline: one building per turn, one floor per tool call.

The sky at your local time of day: sun by day, moon and stars by night, more stars the longer the session.

Snake that plays itself until you take the keys.

A bar chart that sorts itself one swap per tool call, then reshuffles.

The session as music: a note per tool call, a chord when checks pass and a buzz on failure, with a piano roll. Playback currently works on macOS only.

Underlines file names that do not exist, as you type them in the prompt box, and paints the ones that do green

What a yes would lose, measured from git and written under the permission dialog for a destructive command

Servers this session started that still hold a port, with age and turn, one verb to stop one, and the survivors shown when the next session opens

A live gauge of how fast Claude is writing, in tokens per second, with a sparkline.

One line per tool of your connected MCP servers, called by the widget on a clock with no model: pull requests, errors, the next meeting

The session's task list with a progress bar.

Tetris; it plays itself until you take the keys.

A chart of the turn: one bar per tool call on a time axis, parallel calls stacked, coloured by tool.

How long the current turn has run, with the last, average and longest turn and a sparkline.

The TODO, FIXME, HACK and XXX comments in the repository, counted and listed.

A locomotive that crosses the card pulling one wagon per tool call this turn.

A fair test of another widget: sessions alternate with it on and off, and the card compares how many turns end clean

A typing game for long turns: words fall, taken from your own file names; type them before they land.

A bar per rate-limit window with time to reset and session cost.

Reruns a command after every edit and shows a pass or fail light with the first failing lines.

Context usage drawn as weather, from clear skies to a storm near compaction.

Layout for the widget cards: below the prompt, above it, or docked beside the transcript. Required by every widget.

Every line of hidden context the other widgets add to your prompts, word for word, with a running size

One diorama for the whole session: the sky follows the clock, the weather follows context, a tower rises per turn, a train carries the tool calls and a crab walks through it.