From Concept to Production in 10 Days

January 12, 2026: First commit. A Tauri app skeleton with a basic 3-panel layout.

January 22, 2026: Version 0.2.5. Auto-updates, macOS notarization, multi-agent support, persistent terminals, voice input, image attachments, file-based task storage.

196 commits. 10 days. Production-ready.

This isn't a brag. It's a data point about what's now possible.

The Stack Decision

I needed three things: native performance, real terminal emulation, and cross-platform potential.

Tauri v2 gave me all three. Rust backend for speed and memory safety. Web frontend (React + TypeScript) for rapid UI iteration. SQLite for local-first data that doesn't require a server.

The terminal piece was non-negotiable. Most "terminal apps" fake it—they render monospace text but don't actually connect to a PTY. Rithm needed real shell sessions. portable-pty in Rust handles the spawn, resize, and I/O. xterm.js on the frontend handles rendering.

Why local-first? Latency. When you're searching a codebase or spawning a shell, you need milliseconds, not seconds. No network round-trip. No server to maintain. No auth flow to build.

Local-first also means simpler architecture. Fewer moving parts means fewer things to break and faster iteration.

The Development Phases

Looking back at the commit history, the work fell into distinct phases:

Days 1-2: Foundation

The core architecture—tasks, terminals, database schema. Getting PTY sessions to spawn reliably, stream output to the frontend, and survive component re-renders. Fixing the classic bugs: terminal not resizing, output not rendering, sessions leaking on unmount.

By day 2, I could create a task, open its terminal, run commands, and close the app without losing everything.

Days 3-5: Agent Integration

This was the point of the app, so it came early. First Claude Code—detecting if it's installed, formatting the task as a prompt, sending it to the terminal, monitoring for completion.

Then Codex. Then Gemini CLI. Each agent has its own quirks—different command flags, different auth models, different ways of indicating they're done. The abstraction layer handles it: pick your agent, click send, and Rithm figures out the rest.

Days 5-7: The Details That Matter

LED status indicators. Voice input via Whisper (running locally—no cloud). Image attachments for visual context. Keyboard shortcuts for everything. Light and dark themes.

These aren't core features, but they're the difference between a prototype and something you'd actually use daily.

Days 7-10: Production

Auto-updates via GitHub releases. macOS code signing and notarization (a surprisingly painful process). Configuration management so existing users' data survives updates.

Also: a rebrand. The app was called "Comrado" until day 6. That name didn't feel right. Changed it to "Rithm" in a single commit that touched database names, localStorage keys, identifiers, and every package.json. A global find-replace, run the tests, ship it.

The AI Acceleration Effect

Here's where it gets meta: I used Claude Code to build Rithm.

The project has a CLAUDE.md file—instructions for Claude Code on how to work with this specific codebase. Stack details. Directory structure. Key patterns. It's AI-aware documentation.

When I hit a bug, I'd describe it to Claude, point it at the relevant files, and watch it trace through the code. When I needed a new feature, I'd describe the requirements and let it draft the implementation.

The iteration cycle compressed. Bug found at 2pm, fixed and shipped by 4pm. Not because the bugs were simple—because the search-understand-fix loop is faster with an agent handling the grunt work.

This creates a flywheel: better AI tools make development faster, which lets you build better AI tools faster. Rithm is a tool for managing agents, built using agents.

What I'd Do Differently

Ship even earlier. The first "public" version had too many features. I should have released with just tasks + terminals on day 3 and iterated from there.

Skip the voice input initially. It's a nice feature but took two days to get right, particularly dealing with WKWebView audio APIs on macOS. That time could have gone to other things.

Write fewer features, more tests. The test coverage is thin. When you're iterating this fast, regression bugs are a real risk.

Lessons for Builders

Local-first simplifies everything. No auth, no servers, no billing integration, no GDPR complexity. Just an app that works offline.

Build the tool you want to use. I was frustrated with managing multiple agent sessions. Now I'm not. That's the entire product thesis.

AI-assisted development changes the math. A solo developer can now ship what used to require a team. The constraint isn't engineering capacity—it's knowing what to build.

Ship, then iterate. The version on day 3 worked. Everything since has been refinement. Getting something real into your own hands (and users' hands) teaches you more than planning.

The Numbers

• 196 commits
• 10 calendar days
• 1 developer
• 0 servers
• 3 AI agents supported
• 5 LED states
• ~15,000 lines of TypeScript
• ~4,000 lines of Rust

This is what building looks like now. Not because I'm fast, but because the tools are different.