the blind spots are getting plugged

Table of content

by Ray Svitla

your agent is a black box.

you send a prompt. you wait. you hope. when it finishes, you check the output. if it’s wrong, you guess what went wrong and try again.

this is how most people use coding agents. it works. sort of. until it doesn’t.

the problem isn’t that agents fail. the problem is that when they fail, you have no idea why. no process visibility. no state inspection. just logs that tell you what happened after the fact.

jarrod watts just plugged that blind spot.

claude-hud: the dashboard you didn’t know you needed

claude-hud is a plugin for Claude Code that shows you what’s happening inside the agent’s session. context usage. active tools. running sub-agents. todo progress.

not logs. not output. live state.

the repo hit 1,038 stars on GitHub in 24 hours. the HN thread filled with people saying “I didn’t know I needed this until I saw it.”

the pattern is familiar if you’ve been around infrastructure long enough. every new runtime goes through the same evolution:

  1. it works (mostly)
  2. it fails in production (mysteriously)
  3. someone builds observability
  4. everyone wonders how they lived without it

we’re at step 3 for agents.

when you can see what the agent is doing — which tools it’s calling, how much context it’s using, what sub-agents it spawned — debugging stops being archaeology and becomes observation.

you don’t dig through logs trying to reconstruct what happened. you watch it happen.

this is the same shift that happened with containers (Docker → Kubernetes dashboards), serverless (AWS Lambda → X-Ray), and distributed systems (logs → traces → metrics).

observability isn’t a nice-to-have. it’s the infrastructure layer that makes the runtime usable at scale.

claude-hud is early. it’s not polished. but it’s the first tool I’ve seen that treats agent sessions as observable processes instead of black boxes.

karpathy’s workflow flipped

andrej karpathy (former Tesla AI director, openai founding member) posted this week about his coding workflow.

quote: “over the course of just a few weeks coding in Claude, my workflow flipped almost entirely. what was once mostly handwritten code is now largely driven by LLMs, guided through natural language.”

karpathy isn’t a casual user. he built neural networks for self-driving cars. he helped create GPT. if his workflow flipped, it’s not hype — it’s documentation.

the inflection: we crossed from “AI as helper” to “AI as primary interface.”

what does that mean in practice?

the tools didn’t fundamentally change. Claude 4.6 has been out for weeks. what changed is the mental model.

when you stop thinking “how do I write this?” and start thinking “how do I describe this so the agent can write it?”, the workflow inverts.

this is the same shift that happened with:

each time, the abstraction layer moved up. each time, people said “but you lose control.” each time, the productivity gains outweighed the loss of low-level control.

karpathy’s post matters because he’s not an early adopter chasing hype. he’s a pragmatist who tried the new workflow, found it faster, and switched.

when engineers of that caliber say “the workflow fundamentally changed,” you should probably pay attention.

anthropic’s 73% market capture

field reports from enterprise teams: 73% of AI spend is now on anthropic products. openai dropped to 26%.

the data is anecdotal (Reddit thread, 1,288 upvotes, 69 comments), but the pattern is consistent across multiple reports: enterprises are migrating from openai to anthropic.

the question: “anyone see their workplace switch?”

the answer, over and over: “yes. last month. entire team migrated.”

this isn’t launch hype or early adopter enthusiasm. this is enterprise budgets shifting. when companies move spend at this scale, it’s not about features — it’s about reliability, safety posture, and long-term trust.

what changed?

three things, based on the comments:

  1. reliability: Claude Code sessions don’t drop randomly
  2. safety: anthropic’s constitutional AI approach resonates with compliance teams
  3. developer experience: the workflows just… work

openai pioneered the space. anthropic captured the market.

this is the pattern you see when a market matures: the first mover gets the hype, the second mover gets the enterprise contracts.

think:

anthropic isn’t just competing with openai. they’re defining what “enterprise-grade AI” means.

the infrastructure is maturing faster than the culture

three signals in 24 hours:

the pattern: the infrastructure is maturing faster than the culture can absorb it.

we now have tools to observe agent behavior. we have engineers admitting the workflow fundamentally changed. we have enterprises voting with their budgets.

but most people are still treating agents like chatbots. prompt → wait → hope.

the gap between what’s possible and what’s practiced is widening.

if you’re still writing code the old way, you’re not behind — you’re in a different workflow entirely. and that workflow is about to become legacy.

the question isn’t “will agents replace developers?” — it’s “how fast can you shift your mental model from code-first to intent-first?”

because the people who figure that out first aren’t going to wait for you to catch up.

Ray Svitla stay evolving 🐌