OpenLinear

Every developer I know has the same workflow: read a Linear ticket, context-switch to the IDE, write the code, push a PR, go back to Linear and move the card. That's four context switches per task.

I wanted to collapse that into one click. Select a task on the board, hit 'Execute,' and get a pull request with working code - reviewed, tested, and ready to merge. Not a copilot that autocompletes lines, but an agent that takes ownership of entire tasks.

The gap in the market was clear: AI coding tools operate inside editors. Project management tools have no idea code exists. OpenLinear sits in the middle - it understands both your backlog and your codebase.

OpenLinear is a Tauri desktop app (Rust shell, Next.js UI) with an Express.js sidecar running the OpenCode SDK. When you execute a task, the sidecar spins up an isolated git worktree, runs the AI agent against it, and streams tool calls and file edits back to the UI in real-time.

The kanban board is a full Linear-style project manager - columns, drag-and-drop, labels, priorities, assignments. But every card has an 'Execute' button. Click it and you can watch the agent read files, reason about architecture, write code, and create a PR - all without leaving the app.

GitHub OAuth handles identity. The agent creates PRs under your account. You review the diff right in the app.

Tauri over Electron - Electron bundles an entire Chromium. Tauri uses the system webview and ships a ~3MB binary. For a dev tool that sits open all day, memory matters. The tradeoff: fewer cross-platform guarantees on Linux webview rendering. I accepted that because the primary audience is macOS developers.

Git worktree isolation - Rather than having the agent modify your working directory (and potentially break your in-progress work), each task execution creates a fresh worktree. Parallel tasks run in parallel worktrees. This was non-negotiable for trust: if you can't trust the tool not to corrupt your local state, you won't use it.

Express sidecar over in-process - The OpenCode SDK is a Node process. Tauri's backend is Rust. Instead of bridging FFI, I run Express alongside Tauri and communicate via localhost HTTP. Simpler debugging, independent restarts, and the SDK can evolve without Rust recompilation.

Building AI-powered developer tools taught me that reliability is the entire product. A flashy demo means nothing if the agent hallucinates a file path 5% of the time. I spent more time on error recovery and rollback logic than on the happy path.

The hardest UX challenge was transparency. Developers need to trust the agent. Showing live tool calls and file diffs in real-time - not just the final PR - was the difference between 'this is magic' and 'I'd never let this touch my code.'

Shipping a desktop app in 2026 is still harder than it should be. Auto-updates, code signing, notarization, platform-specific builds - the infrastructure overhead for a solo developer is significant. But the result is a tool that feels native and fast in a way web apps never will.