I was using Cursor. I should clarify what I mean by "using" Cursor, because as it turns out, I wasn't. Not really. I was using it the way someone uses a swimming pool as a paddling pool - technically in the water, achieving approximately none of what the thing was built for.
Here's what I was actually doing: opening multiple terminal panes and running Claude Code in each one. That's it. Cursor's AI features? Never touched them. Its code editing? Barely. Its autocomplete, its inline chat, its clever refactoring tools? Not once. I wasn't even paying for the thing - just using the free version as a glorified terminal organiser. That's like signing up for a gym membership to use the car park.
The moment I realised this was, predictably, the moment I decided to build my own.
The Problem
I run a lot of Claude Code sessions. On any given day I might have three or four going across different projects - one working on Task Board, one on TestPlan, one reviewing a pull request, one doing something experimental that I'll probably regret. The problem is keeping track of them all. Terminal tabs get lost. Windows pile up. You can't see at a glance which Claude is waiting for input and which one is busy thinking about your terrible architecture decisions.
Cursor solved this by giving me a visual workspace with panes. But I was using approximately zero per cent of what Cursor offered and one hundred per cent of the window management. That's like joining a gym for the showers.
So I did what any reasonable developer would do. I opened Claude Code, described what I wanted, and asked it to build it.
Eighty-Nine Minutes to v1.0.0
The first commit landed at 4:14 PM on a Monday afternoon. By 5:43 PM - eighty-nine minutes later - I had a published v1.0.0 release with an installer on GitHub.
I need to be honest about what happened in those eighty-nine minutes, because it still slightly unnerves me. I described what I wanted: an Electron app with multiple terminal columns, each running a Claude Code instance, organised by project. Claude Code wrote the whole thing. The main process, the renderer, the terminal integration via xterm.js, the WebSocket-based pty server, the project switching, the session persistence. All of it.
I reviewed the code. I tested it. I made architectural decisions - like running node-pty in a separate process to avoid Electron's native module compilation nightmare, which anyone who's tried to use native Node.js modules inside Electron will understand is a special circle of dependency hell. But the actual writing of the code? That was Claude, building itself a home.
There's something genuinely unsettling about watching an AI build a desktop application designed to run multiple instances of itself. I'm not going to pretend I didn't think about it.
The Afternoon That Got Away From Me
Here's the thing about building with AI: scope creep happens at the speed of thought.
What started as "I just want columns" became, within hours: a usage dashboard that aggregates token consumption across all your Claude sessions. A file explorer panel. Full git integration - staging, committing, branching, stashing, diffs. Session titles that persist across restarts. Right-click copy and paste. A theme toggle. Environmental impact estimates. An auto-updater that checks GitHub Releases and installs in the background.
By 6:24 PM on day one - about two hours in - I was on v1.0.5. I'd shipped five versions of a desktop application in less time than most standup meetings take to get through yesterday's blockers.
I should also mention that between v1.0.0 and v1.0.5, I accidentally released v2.0.1. Don't ask. Version numbering, like humility, is a journey.
Day two was polish. Fix the paste - which took three separate attempts across three commits, because terminal paste in Electron is a special kind of nightmare involving bracketed paste mode, navigator.clipboard API limitations, and eventually giving up and routing everything through Electron's IPC to the system clipboard. Add activity indicators so you can see which Claude sessions need attention. Clean up the sidebar. Theme work. By mid-afternoon I was on v1.0.8, and the thing I'd built "just for columns" had become a proper IDE.
Thirty-two commits. Twenty-two hours. A published, self-updating desktop application. And I'd barely written any of the code myself.
The Architecture, For Those Who Care
The interesting technical decision was the pty server separation. Electron ships its own Node.js binary with different ABI headers, so any native module needs to be recompiled against Electron's version. This is a well-documented source of developer suffering, and I wasn't about to spend my Monday evening fighting electron-rebuild.
Instead, Claudes spawns a separate Node.js child process that runs under the system Node.js installation. The Electron renderer talks to it over WebSocket. The pty server handles all the pseudo-terminal management via node-pty, and the renderer displays it via xterm.js with WebGL rendering for gap-free block characters. Clean separation, no native module headaches, and the terminals actually look right.
Session management reads Claude Code's own .jsonl conversation files to restore previous sessions on startup. Switch projects and your running Claudes stay alive in the background. Close the app entirely and reopen it - your sessions are waiting for you, titled with whatever you first asked each Claude to do. It's the kind of thing that sounds simple until you try to implement it, and then Claude implements it for you in about four minutes.
The Recursive Irony
I used Claude Code to build a desktop application whose entire purpose is running Claude Code. The AI built itself a house.
This isn't just a cute observation. It's a meaningful data point about where AI-assisted development actually is right now. A year ago, asking an AI to build you a desktop application with terminal emulation, WebSocket communication, native module integration, and auto-updating distribution would have been laughable. Today, it's a Monday afternoon project.
The environmental impact dashboard is the bit that makes me smile, given my last post about sixty-six miles of carbon guilt. The app tracks your token usage across all sessions and estimates the CO2 equivalent per model. So the tool I built to manage my AI usage also guilt-trips me about my AI usage. It's like buying a fitness tracker that tells you the environmental cost of buying a fitness tracker.
Why Open Source
I put it on GitHub because I thought other people might have the same stupid problem. Not everyone wants to use an IDE they're only treating as a terminal multiplexer. And frankly, the more people who use Claude Code as their primary development tool, the more people are going to need something to organise the chaos.
It's not a commercial product. I have enough of those. It's just a tool I built for myself that turned out to be genuinely useful, and sharing it costs me nothing except the occasional GitHub issue from someone who can't get paste to work. Which, given it took me three attempts, is fair.
If you want to try it: it's on GitHub. Download the installer, point it at your projects, and spawn some Claudes. If you find a bug, raise an issue. If you want to add something, send a pull request. I built the thing in a day. I'm under no illusions about its perfection.
What This Actually Means
I keep coming back to the timeline. Not because the speed is impressive in itself - though it is - but because of what it represents. The bottleneck in building Claudes wasn't coding. It wasn't debugging, or architecture, or deployment. It was me thinking of what to build next. Every time I had an idea - "it should track usage", "it should have git integration", "it should show which Claude needs my attention" - the implementation just... happened. Minutes, not days.
That changes what it means to be a developer. Not in the way people keep predicting, where AI replaces programmers. In the way where the programmer's job shifts from writing code to directing it. From typing to thinking. From implementation to vision. The human is still the product manager. The AI just executes at a speed that makes the old way feel like carving stone tablets.
I started this blog eight months ago as a sceptic who asked an AI about archery sights. Now I'm building desktop applications in an afternoon and open-sourcing them before dinner. The trajectory is honestly a bit dizzying.
But the tool works. I've closed Cursor for the last time. And if you'll excuse me, I've got four Claudes running across three projects and they're all waiting for input. The activity indicators are pulsing. Back to work.
