The Self-Improving AI Development Loop

There’s something philosophically satisfying about software that monitors its own development. Not in a Skynet way—in a practical, “this actually solves a real problem” way.

Here’s the setup: You’re using Claude Code to build software. Claude works autonomously for stretches, but periodically needs human input—a permission, a decision, clarification on requirements. If you’re at your desk, no problem. If you’re not, the whole thing stalls.

Pulse solves this by letting you monitor Claude’s terminal from anywhere. But here’s where it gets interesting: what if Claude is building Pulse itself?

The loop

The concept is simple but powerful:

1. Pulse v1.0 (stable) runs in production
2. Claude Code builds Pulse v1.1 on development ports
3. Pulse v1.0 monitors Claude as it works
4. When v1.1 is verified working, deploy it as the new stable
5. v1.1 now monitors Claude building v1.2

The tool watches its own creation. Each version supervises the birth of the next.

This isn’t just elegant—it’s practical. You need a stable monitoring system to safely develop the next version. You can’t test monitoring software without something to monitor. The loop provides both.

Why broadcast everything is wrong

The first instinct when building a remote terminal monitor is to stream everything. Every character, every output, every command—pipe it all to the dashboard.

This is wrong.

When Claude is working autonomously (what we call “yolo mode”), constant streaming creates noise. If Claude is happily refactoring files, you don’t need to see every line scroll by. You need to know when it stops and needs you.

Alert when:

• Terminal waiting for user input
• Error states requiring intervention
• Task completion
• Explicit questions from Claude

Stay silent during:

• Normal code execution
• File operations
• Successful command completions
• Autonomous work that’s proceeding fine

The goal is notification, not surveillance. Surface what matters, suppress what doesn’t.

The “don’t bother me” protocol

This is the key insight that makes autonomous AI development actually work:

Claude should only surface to you when:

• All tests pass and it’s ready for deployment approval
• There’s a blocking decision requiring human input
• Something is fundamentally broken that Claude can’t resolve

Everything else—build failures, test failures, iteration cycles—Claude handles silently.

This flips the traditional development model. Instead of watching the build process, you get notified when it’s done. Instead of reviewing every change, you review the outcome. The AI handles the grind; you handle the decisions.

Self-testing with browser automation

Here’s how Claude verifies its own work without human intervention:

1. Make changes to Pulse
2. Start the dev instance on test ports
3. Run the test suite via Chrome automation
4. Tests pass? Notify human it’s ready
5. Tests fail? Fix and loop back

The test scenarios cover the full stack:

Test	Pass Criteria
Dashboard loads	Page renders, no console errors
WebSocket connects	Shows “connected” status
Terminal appears	Terminal visible in dashboard
Broadcast works	Output appears in dashboard
Input detection	Dashboard shows “needs input” alert
Command relay	CLI receives and executes
Mobile responsive	Layout adapts to viewport

Claude runs these tests, evaluates the results, and either fixes issues or reports success. The human only sees the end state.

Memory that persists

One friction point in AI-assisted development: context doesn’t persist well between sessions. You explain your architecture, Claude understands, the session ends, next time you start from scratch.

The solution is an MCP server that connects Claude directly to a memory bank:

Before: Capture thought → Copy to file → Reference file in Claude → Paste into PRD

After: Capture thought → Push to Pulse → Pull into PRD (no manual steps)

Claude can push context to Pulse from any conversation. Pull it back later. Share it between different Claude instances. The knowledge accumulates rather than evaporating.

Mobile matters

If you’re monitoring AI development, you’re probably not sitting at your desk the whole time. That’s the point—you want to be elsewhere while Claude works.

The dashboard needs to work on phones and iPads:

• Responsive design for small screens
• Push notifications for input-needed states
• Quick command relay from mobile
• Battery-efficient WebSocket handling

You’re on the couch, phone buzzes, Claude needs a decision, you tap a response, Claude continues. That’s the workflow.

The multi-machine future

Right now Pulse runs on a single machine. The roadmap includes:

• Single relay server (Cloudflare) serving multiple CLI instances
• Each machine authenticates to the same relay
• Dashboard shows all connected terminals, grouped by machine
• Machine identification via hostname or custom labels

Picture monitoring three different Claude Code sessions on three different machines, all from one dashboard on your iPad. That’s where this is heading.

Why build this publicly?

If Pulse is good enough for building Pulse, it’s good enough for others. The self-hosting loop proves the tool works under real conditions—the most demanding conditions, actually, since it’s building itself.

Everything learned here applies to other projects. The patterns for autonomous AI development, smart notification, persistent context—these transfer.

And there’s something fitting about documenting the journey on a blog that exists because the tool being documented made it possible to build without constant supervision.

The philosophy

Traditional software development is synchronous. You write code, you watch it compile, you see if it works, you iterate. The human is in the loop at every step.

AI-assisted development can be asynchronous. Claude works while you do other things. But only if you have confidence it’s working correctly, and visibility when it needs you.

Pulse provides that confidence and visibility. The self-improving loop proves it works. Each version validates the architecture by successfully supervising the creation of the next.

It’s turtles all the way down, except the turtles are shipping working software.

---

Pulse is in active development. Follow along at pulsevibe.dev.