What a web terminal unlocks

It's three Lego pieces: a part that draws the terminal on screen, a part that runs a real shell behind the scenes, and a wire between them. These are the exact same parts VS Code's built-in terminal is made of — and Microsoft maintains them — so there's no mystery about whether it works. You used Claude Code inside VS Code for months; that was this.

You can put normal app stuff — a sidebar, buttons, lists, even a small web page — right next to the terminal, and it can see and react to what's happening inside the terminal. Regular terminals can only ever show you text in a grid; they have no place to put a real button.

Every pixel of the window is yours to design — the tabs, the title area, the layout, the fonts. The terminal and the rest of the app can share one look (your Coda styling could cover both). With normal terminals you can change colors and fonts, but the window furniture is whatever the vendor decided.

You can glue a button or badge to a specific line of terminal output, and it stays glued — scrolls with the text, disappears when the line does. Those little green/red dots next to commands in VS Code? That's this. Imagine an "ask Claude about this error" button appearing right on the error line.

Scripts and command-line tools can send invisible messages to your app — nothing appears on screen, but a sidebar panel updates. It's a private walkie-talkie channel between the shell and your UI. No off-the-shelf terminal lets you invent new messages like this.

Everything in the terminal — every command, all its output, with colors — can be saved like a document. Restore a session after a restart, export output as a styled web page, share a link to one command and its result, or open the same terminal on your phone.

Normally a terminal is a firehose of characters — it has no idea where one command ends and the next begins. A tiny tweak to the shell adds invisible bookmarks, so the app knows exactly: here's a command, here's its output, it succeeded (or failed), it ran in this folder, it took this long.

Once the app knows that, the terminal stops being a wall of text and becomes a list of things that happened — which you can navigate, collapse, decorate, and build features on. This is the single most valuable idea in the whole report.

To be fair to the terminals you already use: they're good at a lot. Controlling panes from scripts, fancy status bars, pop-up pickers, inline images, visual effects — all covered. That's the green half of the table.

The red half is the point: none of them can host a real sidebar, let you redesign the window itself, attach buttons to output, accept custom invisible messages, or share one design across UI and terminal. That's not "harder on native" — it's impossible without forking the terminal's source code.

Some news from the research worth knowing: WezTerm — your current terminal — has gone quiet. No proper release in over two years, and requests for exactly the kind of UI you want sit unanswered. Ghostty's creator has said flat-out he'll never add a plugin system. And Warp — the closest commercial product to this idea — had to build an entire terminal from scratch to do it, which rather proves the point.

The trade-offs, honestly: it's a touch slower than the fastest native terminals — about as fast as VS Code's terminal, which you used happily, so you almost certainly won't notice. A few rare quirks with unusual emoji and non-Western text. And it's an app you own — updates and maintenance are on you, though the core is tiny and you already maintain two Electron apps.

Someone already built almost exactly this idea — terminal panels next to AI chat, web pages, and editors — and gave the code away free. It proves the concept works. We'd read their code for answers rather than build on top of it, because their layout isn't quite what you want.

Another existing project with a beautiful architecture worth learning from — but it's been abandoned for three years, so we wouldn't build on it.

The recommendation: start fresh. A working terminal is about 150 lines of code, and everything else gets added piece by piece. You own all of it, inherit nobody's decisions, and reuse patterns from your existing apps.

Bottom line: Claude Code will run in it exactly as it does in WezTerm — it can't tell the difference. The payoff is a terminal that's also an app: your design, your sidebar, buttons on error lines, scripts that talk to panels, sessions you can save and share.

The costs are real but small for your use. The smart path is building it fresh (it starts tiny) while cribbing from the open-source project that already proved the idea.

The one decision deliberately not made yet: whether this becomes the successor to WezTabs + WezTerm as your daily Claude Code home. That's yours to sit with.