A Physical Status Light for Claude Code: Using ESP32 to Stop Staring at Your Terminal

The Hidden Pain Point of AI-Assisted Coding: Who's Watching the Terminal for You?

When using AI coding tools like Claude Code, there's a recurring awkward scenario: after submitting a task, you're forced to hover in front of the terminal, waiting for it to think, execute, or pop up a confirmation prompt. This "hostage-style waiting" is fundamentally a waste of attention — during the tens of seconds or even minutes the AI is working in the background, you're afraid to switch to something else, yet equally afraid to miss a permission request.

Claude Code is Anthropic's terminal-based AI coding tool. Unlike code completion tools such as Copilot, it operates in "Agent" mode: after receiving a task, it can autonomously invoke bash commands, read and write files, run tests, and request user confirmation before high-risk operations. This mode draws from the core ideas of the ReAct (Reasoning + Acting) framework — proposed in 2022 by researchers at Princeton and Google Brain — whose key innovation was interleaving reasoning chains with tool-call actions. Rather than simply generating text, the model first "thinks," then "acts," feeding each execution result back as input for the next round of reasoning, forming a continuous "Think → Act → Observe" loop. This framework significantly improved model accuracy on multi-step planning tasks and became a foundational design pattern for mainstream Agent frameworks like LangChain, AutoGPT, and Claude Code. As a result, Agent mode can handle complex multi-step tasks — but it also introduces unpredictable execution durations and mid-task checkpoints that require human intervention. This asynchronous "delegate → execute → confirm" model is fundamentally different from the traditional synchronous "input → output" interaction, and it's precisely why the "waiting awareness" pain point exists.

One Bilibili creator came up with an answer with a distinctly engineer's flair: build a physical status light that maps Claude Code's real-time state to a lamp sitting below the monitor. A quick glance from the corner of your eye tells you exactly what the AI is doing, completely freeing your gaze from the terminal.

How the Status Light Works: Four Colors, Four States

Color Equals State — Read the Workflow at a Glance

The core logic of this solution is remarkably intuitive, using color to break down Claude Code's working stages:

• Blue (spinning animation): Running — the AI is thinking or calling a tool
• Yellow: Waiting for user permission confirmation (e.g., asking whether to execute a command)
• Green: Task complete
• Red: An error occurred
• Off: Idle, standing by

The hardware heart of the build is an ESP32 development board. The ESP32 is a low-cost, low-power microcontroller launched by Espressif in 2016, featuring a dual-core Xtensa LX6 processor (up to 240MHz), 520KB of built-in SRAM, and integrated Wi-Fi 802.11 b/g/n and Bluetooth 4.2/BLE. Its dual-core architecture can distribute network communication and application logic across separate cores for parallel processing, preventing the Wi-Fi driver from stealing CPU time from the application layer — a critical advantage for LED driving scenarios that require precise timing. Espressif also provides a comprehensive IDF (IoT Development Framework) and an Arduino compatibility layer, allowing a large body of Arduino community libraries to be ported directly. It's currently one of the most popular embedded development platforms in the maker community. At a cost of a few tens of yuan and backed by the Arduino and MicroPython ecosystems, it's the go-to choice for networked hardware projects. On boot, the ESP32 first connects to Wi-Fi, then automatically cycles through all light effects once connected — serving as both a self-test and a confirmation that the hardware chain is working.

A Complete Interaction Demo

The creator ran through the full workflow in their video. After posing a question to Claude, the light first turns blue and starts spinning, indicating the AI has begun calling tools to advance the task.

The first test happened not to trigger a permission confirmation, so the light jumped straight from blue to green. To demonstrate the full chain, they deliberately ran Claude through a flow that required confirmation:

Blue (running) → Yellow (awaiting user confirmation) → Blue again after confirmation (continuing) → Green (complete)

This state machine maps precisely to Claude Code's actual working rhythm — and crucially, it singles out "waiting for permission confirmation" with a dedicated yellow light, addressing the stage most easily overlooked yet most in need of human intervention.

Why This DIY Project Deserves Attention

From "Active Polling" to "Passive Awareness"

The greatest value of this project isn't its technical complexity — it's the precise insight into workflow experience. The creator's own words put it well: "Once I ask a question, I can use the monitor to do something else. A glance at the corner of my eye tells me it's working if the light is blue, and if it turns yellow, I know it's asking for my permission."

At its core, this transforms active polling (staring at a refreshing terminal) into passive awareness (peripheral light perception). Human perception of color and light is essentially zero-cost, allowing developers to genuinely switch into other tasks during the AI's execution window without worrying about missing a critical moment.

A New Approach to "Ambient Awareness" in the Agent Era

As AI Agent tools like Claude Code and Cursor become widespread, human-AI collaboration is evolving from "question and answer" to an asynchronous "delegate → wait → confirm" model. In this paradigm, how to let people track AI state with the lowest possible cognitive overhead has become a genuine product design challenge.

A physical status light is a humble implementation of Ambient Computing — a concept rooted in the foundational 1991 paper The Computer for the 21st Century by Xerox PARC researcher Mark Weiser. Weiser and his colleague John Seely Brown further developed the philosophy of Calm Technology: good technology design should fluidly shift between the "center of attention" and the "periphery of attention," entering the user's focus only when needed and otherwise receding into the background to serve people without interruption. A physical status light is a textbook implementation of calm technology — light changes require only peripheral perception, trigger no screen notifications, don't interrupt the current task flow, and only naturally draw attention when the color switches.

This philosophy was brought into the agile development community in the 2000s by Alistair Cockburn, evolving into the practice of Information Radiators: the idea that teams should display key metrics in physically visible forms in the workspace, so that information "finds people" rather than "people finding information." The classic build status light in CI/CD is one of the earliest real-world implementations of ambient computing in software engineering — teams at Facebook, Google, and others have hung physical lights next to workstations, with red meaning a broken build and green meaning a healthy trunk. This creator has transplanted the same logic into the AI coding context — and the timing couldn't be better.

Building Your Own: Barrier to Entry and Open Source Resources

From a hardware perspective, the cost to replicate this is quite low:

• ESP32 development board: A few tens of yuan
• Programmable RGB light: Such as WS2812 LEDs or a ring module. The WS2812 (and its improved WS2812B) was designed by WorldSemi, with its key innovation being the integration of a PWM control IC directly inside each RGB LED, enabling single-wire serial daisy-chain control — any number of LEDs can be driven from a single GPIO line. Each LED receives its own 24-bit RGB data and forwards the remaining data to the next LED in the chain. Its communication protocol transmits data via precisely timed high/low voltage pulses (0-bit: ~0.35μs high + ~0.8μs low; 1-bit: ~0.7μs high + ~0.6μs low). The ESP32's RMT (Remote Control Transceiver) hardware peripheral was originally designed for infrared remote control signals, but its programmable high-precision timing control happens to meet the strict requirements of the WS2812 protocol — it can generate drive signals without consuming CPU resources and without needing an external LED driver IC, greatly simplifying the circuit design. This creative use case has been included in the official ESP-IDF documentation as a standard example.
• State push scripts: Claude Code provides a comprehensive Hook system, allowing developers to register callback scripts for specific events in the configuration file — such as PreToolUse, PostToolUse, Stop (model completes a response), and other key checkpoints. These hooks execute as subprocesses and receive a JSON context containing the current state, tool name, execution result, and more. Developers write shell scripts to listen for these events and push state changes to a lightweight web server running on the ESP32 via HTTP requests. The end-to-end latency of the entire chain is typically under 100 milliseconds — more than sufficient for a near-real-time status feedback experience. This Hook design supports not just the status light scenario, but also automated audit logging, cost monitoring, and other extensions, reflecting Claude Code's forward-thinking approach to Agent safety.

The creator has published the complete source code in their video comments, available for any interested developer to use as a reference.

For developers who rely heavily on Claude Code or Cursor, this small DIY project may genuinely improve the rhythm of daily work. It also reminds us: improving AI collaboration efficiency sometimes doesn't require a smarter model — a more thoughtful interaction design is enough.

Conclusion

This status light sitting below the monitor is a quintessential "small but elegant" engineering piece. It involves no flashy algorithms, yet it hits squarely on a real pain point of the AI coding era — how to stay composed during asynchronous collaboration. As more and more tasks are delegated to AI Agents, what we need isn't just smarter models, but more human-centered state feedback mechanisms. From Mark Weiser's vision of ambient computing and calm technology, to software teams hanging up build status lights, to developers today crafting physical awareness interfaces for AI Agents — the path toward computing that recedes into the environment has never stopped being explored. The ReAct framework gave AI the ability to act continuously; the ESP32 and WS2812 hardware combination lowered the barrier to physical feedback; and Claude Code's Hook system provides the standardized bridge between software and hardware. This lamp is a worthy starting point on that journey.