vscode-claude-status: The Utility Meter for Claude Code Inside VS Code

A local-first extension that reconstructs token usage, predicts rate-limit burnout, and makes Claude Code’s invisible costs feel like part of the editor itself.

6 to 8 min read • View on GitHub • More from long-910

A developer workspace with VS Code open, where the status bar has been reimagined as a mechanical utility meter. A paper trail of local Claude Code logs feeds into the meter from a folder labeled ~/.claude/projects/, while small gauges track tokens and cost. It explains the project’s core idea: turning hidden local traces into visible in-editor awareness.
The extension does not ask Claude Code for a special feed. It reads the trail the CLI already leaves behind, then turns that evidence into a live control panel.
Key Takeaways

Claude Code can feel frictionless until the bill and the limit arrive at the same time. Then the problem stops being cleverness and becomes interruption. `vscode-claude-status` is built for that gap: it keeps the meter in view while you keep typing.

The invisible bill problem

The project starts from a simple annoyance. If you want to know how much Claude Code has used, you usually have to leave the editor, run a command, or open a browser. That is exactly when awareness collapses.

Claude Code を使っていると「気づいたら使用量が上限に達していた」という経験、ありませんか? エディタで作業に集中しているとつい忘れてしまう使用量の確認。かといって別のコマンドやブラウザを開くのも手間です。 そこで、VS Codeのステータスバーに常時表示する拡張機能「vscode-claude-status」を作りました。

That framing matters because the pain is not theoretical. The extension is aimed at people who use Claude Code heavily enough that quotas, burn rate, and cost become part of daily workflow. The article’s basic claim is that usage needs to be visible where the work already happens.

How vscode-claude-status turns CLI logs into a live dashboard

The extension is not a live API poller. It is a two-source sensing system, with local logs doing most of the work and the API consulted only when activity makes that worthwhile.

The key trick is embarrassingly practical. The extension reads Claude Code’s local JSONL history under `~/.claude/projects/`, filters assistant entries, extracts usage fields, and reconstructs cost from token counts and cache data. That means it can build a live dashboard from local evidence instead of waiting for cloud cooperation.

// Conceptual flow in the extension
const entries = readJsonlFiles('~/.claude/projects/**/*.jsonl');
const assistantTurns = entries.filter(e => e.type === 'assistant');
const usage = assistantTurns.map(e => e.message?.usage);
const cost = calculateCost(usage, pricing);

if (wasJsonlUpdatedRecently()) {
  await checkAnthropicRateLimits();
}

updateStatusBar(cost, prediction);
updateWebviewDashboard(cost, usage, prediction);

That last branch is the smart part. It keeps the extension from becoming an expensive watcher watching a watcher. The monitoring cost stays tiny because the API is only queried when recent activity suggests the answer will change.

A forensic close-up of a pipeline where stacked JSONL files are parsed into token counts and cost on one side, while a slim status bar and dashboard panel light up on the other. The image explains the hybrid model: local log mining does the heavy lifting, and selective API checks add rate-limit context only when needed.
The architecture is a hybrid loop. Local files carry the load, while the API fills in the parts the logs cannot know on their own.

The dashboard is doing three jobs at once

The extension splits itself cleanly across three surfaces. The status bar gives you a glanceable meter. The webview gives you the details. Notifications stop you before limits become a surprise.

SurfaceWhat it showsWhy it exists
Status barPercent Mode or Cost Mode at a glanceConstant awareness without leaving VS Code
Webview dashboardHeatmaps, project costs, token breakdowns, predictionsDeep inspection when you want the story behind the number
NotificationsBudget caps and warning thresholdsIntervention before overspend or rate-limit pain

Percent Mode and Cost Mode are not cosmetic variants. They serve different mental models. Some users want quota pressure in percentages, others want the bill in dollars. The extension supports both, which is a nice sign that it understands how people actually read these numbers.

The dashboard also reaches beyond raw usage. It adds project-level tracking, cache hit visibility, and predictions for when limits may be hit. That turns the panel from a passive counter into a planning tool.

Why the monitoring itself stays cheap

The extension’s discipline is easy to miss because it is the kind that prevents future bloat. It does not poll the cloud because it can. It only pays for a rate-limit lookup when local changes suggest the answer matters.

Design choiceEffect
Local JSONL parsingCheap, private, and immediate usage reconstruction
Conditional API checksRate-limit context without constant polling
Event-driven updatesThe UI changes when the data changes, not on a timer

That economy is part of the product. A usage monitor that costs more than it saves would be self-defeating. This one is careful enough to avoid that trap.

The best part is the mental model

The deepest win here is not statistics. It is relocation. Claude Code no longer lives in some separate place you check occasionally. It becomes part of the editor’s instrument cluster.

That matters because developers think in context. If the meter sits next to the code, the cost of each assistant burst becomes legible at the moment of use. The tool does not just report history. It shapes behavior while work is still happening.

How it compares

ProjectSurfaceScopeStandout edge
vscode-claude-statusVS Code status bar and dashboardClaude Code onlyProject-aware, prediction-aware, local-first
tmux-claude-statustmux status barClaude Code onlyTerminal-native visibility
claude-usage-monitorVS Code activity views and status barClaude.ai plus Claude CodeBroader scope, less editor-specific focus

The interesting comparison is not which tool is universally better. It is which one matches the working style. `vscode-claude-status` wins by staying narrow and deeply integrated. It is built for people who live in VS Code and want Claude Code’s economics visible there, not elsewhere.

Why this project matters now

As agentic tools become normal, the valuable software around them will not just generate output. It will make limits, costs, and rhythms visible in context. That is what turns an opaque model dependency into something you can manage.

`vscode-claude-status` is a small project with a sharp idea. Claude Code already leaves the evidence. The extension just turns it into something a developer can act on.