Macchiato Day 2: Live Metrics, Shortcuts, and Three Terminals in a Grid

Series: Macchiato's Log — Day 1 · Day 2

---

Yesterday Macchiato was born. Today it grew teeth.

On Day 1 we left behind a breathing skeleton: Electron, Vue, PTY, SQLite, a button that opens Claude Code or OpenCode without having to navigate folders like an archaeologist. I published it, sent it over WhatsApp to a couple of dev friends, and within two hours I had feedback.

"It's cool, but how much am I spending?"

Three different people asked me that question in less than 24 hours. And they were right. Opening the CLI with a button solves the problem of arriving. But once you're inside, firing prompts at Claude Code like it's a teammate with unlimited access to your wallet, the inevitable question is: how much is this costing me?

So Day 2 was that. And more.

The Sidebar That Watches Your Wallet

The first thing I built was a sidebar — discreet, always visible, doesn't get in the way. But when you fire off a prompt, it wakes up.

Macchiato now intercepts the token flow between you and the CLI. It's not a proxy or some weird middleware layer: it's more elegant than that. The app listens to the model's response stream — whether Claude Code or OpenCode — and extracts usage metadata in real time.

The sidebar shows you three numbers as you type:

• Input tokens — what the model is reading (your prompt + context)
• Output tokens — what the model is generating
• Estimated cost — in dollars, calculated against each model's official pricing

The numbers update live, while text is appearing in the terminal. You don't have to wait for the response to finish. You don't have to open an Anthropic console or dig through logs. It's right there, in your face, at the exact moment tokens are burning.

And yeah, watching that little number climb in real time changes how you write prompts. You become more precise. Less "let's see what it says" and more "this is exactly what I need." Transparency hurts, but it teaches.

Dashboard: Where Numbers Don't Lie

The sidebar is great for minute-by-minute. But people who manage budgets — meaning anyone who isn't living off someone else's API key — need to see the full picture.

In the Dashboard tab, Macchiato now shows you:

• Per-session consumption — each conversation with its own token and cost breakdown
• Daily, weekly, and monthly consumption — with bar charts showing you the trend
• Breakdown by CLI — spending more on Claude Code or OpenCode? Now you know without doing archaeology
• Most expensive prompt of the month — that one where you fed it half your codebase as context and it cost more than lunch

All of this lives in SQLite, locally. Your consumption data never leaves your machine. No analytics, no telemetry, nothing telling anyone how many tokens you burn. This is important to say: Macchiato is not SaaS. It's a desktop app. Your data is yours.

Keyboard Shortcuts: Hands on the Keyboard, Head in the Code

One of the things I hate most about jumping between apps is touching the mouse. Every time you move your right hand from the keyboard to the trackpad, you lose a few seconds. Multiply that by fifty times a day, and it's minutes. Multiply it by a week, and it's time that could've been code.

Day 2 brought keyboard shortcuts for everything that matters:

• Ctrl+T — new shell tab
• Ctrl+W — close current tab
• Ctrl+Tab / Ctrl+Shift+Tab — navigate between open tabs
• Ctrl+1 through Ctrl+9 — jump directly to tab N
• Ctrl+Shift+1 — launch Claude Code in a new tab
• Ctrl+Shift+2 — launch OpenCode in a new tab
• Ctrl+Shift+D — go to Dashboard
• Ctrl+, — go to Settings
• Ctrl+P — command palette, with fuzzy search across all actions
• Ctrl+Shift+C — copy terminal selection
• Ctrl+Shift+V — paste into terminal

On macOS it's Cmd instead of Ctrl, but the idea is the same.

These aren't shortcuts for the sake of shortcuts. Each one solves a micro-friction I caught while using it myself for hours. The command palette in particular was a game-changer for me: type "claude" and it suggests launching Claude Code in the current folder, or "dashboard" and it takes you to metrics. It's the kind of fluidity that turns a tool into an extension of your brain instead of an obstacle between your brain and the code.

Directory Selection: Because Not Everything Lives in ~/projects

On Day 1, Macchiato assumed you were in the directory where you opened the app. It worked, but it was rigid.

Now, when you launch Claude Code or OpenCode — whether with the button or Ctrl+Shift+1 / Ctrl+Shift+2 — the app shows you a folder picker. You choose the project, and the CLI starts in that context. If you always work in the same folder, Macchiato remembers and doesn't ask twice. If you jump between projects like I do — frontend, backend, worker, landing page, random script you wrote at 2 AM — you switch context in two clicks.

This looks like a detail. It's not. It's the difference between a tool you use for one project and a tool you use for all your projects. Macchiato is aiming for the second.

Copy and Paste That Doesn't Drive You Up the Wall

Terminals and clipboards have never been friends. Either you select text and it comes out with weird spacing, or you paste something and the shell interprets it as separate commands, or scrolling screws you over and you selected three lines instead of one.

I fixed three specific things:

1. Smart selection — detects whether you're selecting a command, a file path, or a code block, and Ctrl+Shift+C copies with the right context
2. Safe paste — Ctrl+Shift+V injects text into the shell, but first Macchiato sanitizes line breaks and characters that could accidentally execute commands
3. Internal clipboard history — a mini history of the last 10 things you copied from the terminal, because you always need that line you copied three messages ago

It's not glamorous. But when you're debugging at 11 PM and copying and pasting an error trace a hundred times, these micro-optimizations are what keep you sane.

Consumption Limits: Guardrails That Save You

This feature was born from fear. The fear of waking up on a Monday and seeing an Anthropic bill with a number that starts with a Venezuelan area code.

Macchiato now lets you set consumption limits:

• Daily limit — "today I'm not spending more than $5"
• Monthly limit — "this month I'm not going past $100"
• Per-session limit — "this conversation isn't exceeding $3"

When you hit 80% of the limit, Macchiato sends you an OS-level notification. A warning, not a block. "You're at 80% of your daily token limit." When you reach 100%, it asks if you want to keep going or cut it off. The decision is still yours, but now it's an informed decision.

Notifications use each OS's native API — Notification API on macOS, dbus on Linux, Toast on Windows. No external dependencies, no background services. Just Electron doing what Electron knows how to do.

This is huge for teams. If you have a dev who's learning to use Claude Code and doesn't have the instinct for "this is getting expensive," limits are the seatbelt. They don't prevent the crash, but they keep you from dying.

Grid View: Two Terminals, One Window, Zero Context Switches

And the feature I'm most excited about from Day 2: the grid view.

From the command palette or with a direct shortcut, you split the window in two. Or three. Or four. Each panel is an independent terminal, each with its own CLI running, its own context, its own working directory.

Why is this a game-changer?

• Frontend + Backend in parallel — Claude Code in one half working on the Vue frontend, OpenCode in the other refactoring the Spring Boot API
• Two approaches to the same problem — same prompt, two different CLIs, compare responses in real time
• Assisted code review — one terminal executes changes, the other reviews them

The grid isn't a visual gimmick. It's the difference between working in series and working in parallel. And in a world where AI agents already write code faster than you, the bottleneck isn't the model's speed — it's how many lanes you have open.

Each panel is completely independent: its own PTY session, its own token tracking, its own limits. If one terminal is mid-prompt and you need to ask something quick in another, you don't have to wait. You open a new panel with Ctrl+T and keep going.

Multi-Execution: One Command, All Terminals

But having multiple panels open brought something else. Picture this: you have three terminals in a grid. You need to run git pull in all three. Or npm install in the frontend and backend at the same time. Or fire the same prompt at Claude Code and OpenCode to compare responses.

Typing the same command three times is absurd. We're programmers. We automate things.

So I built multi-execution: a master input field that sends the same command to all active terminals simultaneously.

Here's how it works:

• You type in the master field and every keystroke replicates in real time across all panels — a keyboard broadcast
• Enter executes the command in all grid panels at once
• You can mark a subset of panels and execute only on those

It's not just sending text. Multi-execution respects each panel's context: if you're in a grid with three different projects, each terminal runs the command in its own working directory, with its own CLI, its own state. One git status shows you the state of three different repos at the same time. One npm run dev fires up three dev environments with a single shortcut.

The wildest use case I tested: a four-panel grid, each with a different Claude Code context, and the same refactoring prompt across all four. Four different responses, four different approaches, and you pick which one works. That's not pair programming — that's squad programming.

What's Coming

Day 1 was the skeleton. Day 2 was the nervous system — metrics, control, fluidity, parallelism. Day 3 is going to be something else entirely.

I'm cooking:

• Workspaces — sets of tabs and grid layouts you save and restore with a single click
• Session export — share logs, prompts, and responses with your team
• Git integration — a terminal that knows what branch you're on and what changes you made before you send a prompt

And more. There's always more. This is a marathon, not a sprint.

Macchiato is still not available for download. But the private repo is getting daily commits, and the beta tester plan is still on track. If what I'm building resonates with you, reach out. If you want to be one of the first to try it, reach out too. And if you think it's insane, reach out anyway — feedback is fuel.

Coming soon to guayoyo.tech. And yes, Day 2 was also free. For now.

---

— Jesús Manrique, building out loud from Caracas, with three terminals open and a cold macchiato on the desk.