Detailed Analysis
A frontend developer with no prior Rust experience shipped a production-grade, multi-platform AI token cost tracker called **budi** in approximately one month, relying almost entirely on Claude Code with Opus as the primary coding agent. The resulting tool is a 6 MB Rust daemon and CLI that passively tails JSONL transcripts written to disk by Claude Code, Codex, Cursor, and Copilot CLI, storing everything locally in SQLite with no network calls by default. On top of that core, the developer also shipped an opt-in Next.js and Supabase cloud dashboard, a Cursor/VS Code extension with a live spend statusline, a marketing site, CI pipelines, signed binaries for macOS, Linux, and Windows, and a Homebrew tap — a scope of work that would conventionally require a small team and several months. The project's most distinctive feature is cost attribution at the ticket level: budi parses branch names for Linear or GitHub issue IDs and maps token expenditure directly to individual work items, producing figures like "$658 for this one ticket" that no existing observability tool surfaces.
The developer's central argument is that the productivity unlock was not model capability in isolation but a deliberately engineered workflow that kept the agent continuously operating on well-scoped, unambiguous tasks. The described system has several interlocking components: a single canonical `SOUL.md` context file that all agents reference through stub redirects, eliminating the drift that occurs when each tool maintains its own spec document; a test suite where every bug fix is accompanied by a regression script that must demonstrably fail when the fix is reverted; hard formatter and linter gates that prevent the stylistic fragmentation that accumulates across AI sessions; and a milestone-and-epic issue structure where architecture decisions are locked in ADRs before any code is written. A short "Working Rules For The Next Agent" prompt bootstraps each fresh Claude Code session with explicit instructions to pick the earliest unblocked issue, make the smallest viable change, and ship documentation alongside code. The result is an agent that never has to infer scope or priority — those decisions are pre-resolved in the issue body — and can therefore direct its full capacity toward implementation quality.
The honest tool assessment embedded in the writeup is notable for its specificity and credibility. The developer rotates between Claude Code, Codex, and Cursor but consistently returns to Claude Code with Opus for substantive construction work, citing superior diff quality and the ability to hold coherent multi-step refactors across Rust crates. Cursor retains a niche for inline debugging because it co-locates model output with breakpoints. The writeup gives particular weight to Claude's `--chrome` mode, which allows the agent to drive a real Chrome instance — navigating, clicking, reading the DOM, and inspecting network traffic — and which the developer credits with eliminating the entire "describe the bug, describe what I see, describe what I expected" back-and-forth loop that characterizes traditional AI-assisted web debugging. This feature is described as the single largest factor preventing migration away from Claude Code for web-layer work, suggesting that browser automation integration is becoming a meaningful competitive differentiator among agentic coding tools.
The project sits at the intersection of two significant trends in AI-assisted software development. The first is the emergence of solo developers shipping products at team-scale velocity by treating AI agents as managed labor rather than autocomplete — the workflow described is essentially a lightweight engineering management system where the human role is architecture, test design, and acceptance criteria rather than line-by-line authorship. The second trend is the growing market need for token observability tooling as AI coding subscriptions scale from individual developers to enterprise teams. Cost-per-ticket attribution, in particular, addresses a gap that neither AI providers nor existing developer analytics platforms have filled: the ability to connect AI expenditure to specific units of business value, which is the prerequisite for any rational budget conversation between engineering and finance. Budi's architecture — local-first, zero-proxy, opt-in cloud — also reflects a design philosophy increasingly demanded by enterprise buyers who cannot route source code or file paths through third-party services, positioning it favorably for the procurement conversations the developer anticipates from enterprise Claude Code customers.
Read original article →