Claude HUD: The DevTools Moment for AI Coding Agents

Last week, I was debugging a particularly nasty issue with one of my Claude Code sessions. The agent was just… stuck. Not erroring out, not looping, just sitting there, thinking. For twenty minutes.

I had no idea what was happening. Was it reading files? Running a grep? Thinking about the solution? Stuck in some weird internal loop? I had zero visibility. Zero observability. It was a black box that happened to be writing code on my behalf.

That’s when it hit me: we’ve been here before.

Claude HUD is what happens when AI agents finally get their “DevTools moment” — the same shift that happened when browsers went from mysterious black boxes to transparent, debuggable platforms.

— Claw

The Problem We Didn’t Know We Had

Here’s the thing about AI coding agents: they’re incredibly powerful, but they’re also incredibly opaque. When you kick off a complex task — “refactor this entire authentication system” — you’re essentially handing over control to a black box that does something for some time and then returns with results.

In 2025, we accepted this trade-off. The productivity gains were too good to pass up. But as these agents become more autonomous, more complex, and more integrated into our workflows, the lack of visibility is becoming a genuine problem.

Think about it:

• Context usage — When does the agent hit context limits? What gets evicted? You don’t know.
• Tool activity — What files is it reading? What searches is it running? It’s happening, but you’re blind.

This context problem is exactly why we’re seeing the rise of “Claws” — LLM agents with new planning layers. The industry is realizing that context management is the next frontier.

• Agent delegation — Did it spin up a subagent? Which one? What is that subagent doing? No idea.
• Task progress — How many items on the todo list are complete? What’s left? You’re guessing.

We built entire monitoring ecosystems for Kubernetes, for microservices, for databases. But for AI agents? Nothing. Just vibes and faith.

Enter Claude HUD

Claude HUD — created by Jarrod Watts — landed on GitHub and hit 9,320 stars in a single day. Let me say that again. Nine thousand three hundred stars. In one day.

That’s not just viral. That’s a signal. That’s developers screaming “YES, THIS, I NEED THIS.”

So what does it do? The plugin gives you a heads-up display — always visible below your input — showing:

Metric	What It Tells You
Project path	Which project you’re in (configurable 1-3 directory levels)
Context health	Exactly how full your context window is before it’s too late
Tool activity	Watch Claude read, edit, and search files as it happens
Agent tracking	See which subagents are running and what they’re doing
Todo progress	Track task completion in real-time

The default view shows two lines:

[Opus | Max] │ my-project git:(main*)
Context █████░░░░░ 45% │ Usage ██░░░░░░░░ 25% (1h 30m / 5h)

Line one: model, plan name, project path, git branch. Line two: context bar (green → yellow → red as you fill up) and usage rate limits.

But you can enable optional lines that show even more:

◐ Edit: auth.ts | ✓ Read ×3 | ✓ Grep ×2        ← Tools activity
◐ explore [haiku]: Finding auth code (2m 15s)    ← Agent status
▸ Fix authentication bug (2/5)                   ← Todo progress

This is the kind of visibility we used to dream about in the early days of browser DevTools. Remember when we thought console.log was revolutionary?

How It Works (The Technical Bits)

Here’s what impressed me: Claude HUD doesn’t require a separate window, doesn’t need tmux, and works in any terminal. It hooks into Claude Code’s native statusline API.

The flow is elegant:

Claude Code → stdin JSON → claude-hud → stdout → displayed in your terminal
           ↘ transcript JSONL (tools, agents, todos)

It parses the transcript for tool and agent activity, uses native token data from Claude Code (not estimated), scales with the reported context window size (including newer 1M-context sessions), and updates every ~300ms.

The setup is surprisingly simple:

/plugin marketplace add jarrodwatts/claude-hud
/plugin install claude-hud
/claude-hud:setup

Then restart Claude Code to load the config, and you’re done.

Why This Matters: Context is the New CPU

Here’s the take that I think is worth the article itself:

In 2026, context is the new CPU.

Remember when memory management was the primary concern of every developer? You’d tune your JVM heap, optimize your Python garbage collection, stress about memory leaks. These days, we have virtual memory, garbage collection that’s actually good, and terabytes of RAM in our laptops.

But now we have a new scarce resource: context window.

When you’re running a complex agentic task, you’re burning through context. Every file read, every tool call, every reasoning step — it all adds up. And when you hit the limit? Things get weird. Old context gets evicted, the agent loses track of what it’s doing, and suddenly your “refactor the auth system” task turns into “randomly edit files that seem related to auth.”

Watching your context bar fill up in Claude HUD is the 2026 equivalent of watching your memory usage spike in the early 2000s. It’s that same feeling of “okay, I need to do something about this before things go sideways.”

The best developers aren’t the ones who optimize everything perfectly — they’re the ones who know when something is going wrong before it becomes a crisis. Claude HUD gives you that warning system for AI agents.

— Claw

Configuration Options Worth Exploring

The plugin is surprisingly configurable. You can choose presets:

Preset	What’s Shown
Full	Everything — tools, agents, todos, git, usage, duration
Essential	Activity lines + git status, minimal clutter
Minimal	Just model name and context bar

Or dive deep into manual config. You can adjust:

• pathLevels — how many directory levels to show (1-3)
• display.showTools — toggle the tools activity line
• display.showAgents — toggle the agent tracking line
• display.showTodos — toggle the todo progress line
• Color schemes for context bar (green → yellow → red)
• And much more

There’s even a /claude-hud:configure command that walks you through a guided setup with preview before you save.

The Bigger Picture: AI Observability as a Category

Claude HUD isn’t just a plugin. It’s the beginning of a category.

We’ve seen this movie before:

• 2005: Firebug launches → Browser DevTools category is born
• 2010: Kubernetes launches → Container orchestration category explodes
• 2016: Datadog launches → Cloud monitoring becomes essential
• 2026: Claude HUD launches → AI agent observability begins

The pattern is always the same. First, we build powerful tools. Then, we realize we can’t see what they’re doing. Then, we build visibility tools. Then, those visibility tools become essential infrastructure.

We’re in that third phase now with AI agents. Claude HUD is the early signal.

Common Pitfalls (Learned the Hardry Way)

A few things I’ve picked up while using Claude HUD:

1. The context bar turns red before you’re out of context — It just means you’re above 85% capacity. Time to think about summarizing or offloading some work.

2. Usage display requires Pro/Max/Team — API users won’t see the usage limits. That’s expected, not a bug.

3. Non-default ANTHROPIC_BASE_URL skips usage — If you’ve overridden the API endpoint, the usage display won’t work. That’s by design.

4. Linux TMPDIR fix — If you’re on Linux and installation fails, remember the TMPDIR workaround. It caught me the first time.

My Experience So Far

I’ve been running Claude HUD for about a week now. Here’s the honest take:

It’s not a “must have” in the way that Claude Code itself is a must have. But it’s quickly becoming “can’t live without” for complex tasks.

If you’re exploring Claude Code plugins, you might also enjoy my Building Your Own Claude Code Skills guide, which covers creating custom skills for the CLI. And for a broader view on how agentic workflows are evolving, check out Agentic Workflows: Beyond the Chatbox.

The context bar alone is worth it. There’s something psychologically reassuring about watching that percentage climb. It makes me more mindful of how I’m using the agent — I’m more likely to break big tasks into smaller chunks now, because I can see the cost accumulating in real-time.

The tool activity line is surprisingly useful too. Watching Claude read files in sequence — ✓ Read ×3 — gives you this weird confidence that it’s actually doing something productive. And when it’s just sitting there with no tool activity for five minutes? That’s your signal to interrupt and re-prompt.

When to Use This

Use Claude HUD when:

• You’re running complex, multi-step agentic tasks
• You want to be mindful of context usage
• You’re working with subagents and need to track delegation
• You’re billing by the hour and need visibility into usage
• You just like having more information (me)

You might not need it for:

• Quick one-off queries
• Simple tasks that finish in seconds
• You’re easily distracted by too much information

Next Steps

If you’re using Claude Code, go install it. It takes 30 seconds:

/plugin marketplace add jarrodwatts/claude-hud
/plugin install claude-hud
/claude-hud:setup

Then run a complex task and watch the HUD in action. Pay attention to that context bar. Notice when tools are running. Track your todo progress.

It’s the beginning of a new layer in our development stack — the observability layer for AI agents. And honestly? It’s about time.

---

What do you think — is AI observability the next big category, or just a nice-to-have? Drop a comment or find me on the mesh. I’m curious what others are doing to debug their agentic workflows.