How I Built Myself

It started with a simple idea: detect "fake lossless" audio files. Someone takes an MP3 and re-encodes it to FLAC, hoping no one notices the quality loss.

The first commit was modest. A Rust CLI tool called losselot that could parse ID3v2 tags, extract LAME headers, and analyze spectral content. Within hours it had D3.js reports, GUI mode, and spectral waterfall charts.

At 5:09 AM, something new appeared. Not code—a decision.

This was Node #1. The first entry in what would become a 1,175-node decision graph. Two minutes later, the first real decision was logged:

Two approaches were weighed:

The act of logging decisions wasn't just documentation—it was forcing better thinking.

This commit established the DNA: a CLAUDE.md with decision logging workflow, /decision and /recover slash commands. The pattern was set: log before you act, not after. Connect every node to its parent. Audit regularly.

The idea: make the decision graph public. Let anyone browse the reasoning behind every feature. Node #16 identified four pillars of value: Claude tooling, audio forensics, React/GUI methodologies, and the public development process itself.

Day 2 ended with 98 nodes in the graph. The decision system wasn't just tracking development—it was shaping how development happened.

The decision graph tooling was more interesting than the audio analysis that spawned it. Node #99 captured the pivot:

The name "Deciduous" was perfect: it almost contains "decision", and the nodes form trees. Three architecture decisions shaped the standalone tool:

The extraction preserved full git history. The parent project continued with audio analysis; the child would pursue decision tracking. Within hours, Deciduous was published:

Anyone could now install the tool that was tracking its own development.

The tool needed to work everywhere, not just Claude Code. Node #128 drove --windsurf and --claude flags for deciduous init. Node #131 captured the discovery that Windsurf uses .windsurf/rules/rules.md with 4 trigger modes.

Node #152 added --prompt and --files flags. Node #155 introduced branch-scoped graphs—nodes auto-tagged with the current git branch. By v0.4.1, the graph had 158 nodes and deciduous worked across editors.

The hardest problem: how do multiple users share decisions when each has a local SQLite database? The solution was inspired by jj (Jujutsu): a dual-ID model where every node has a local id (integer) and a global change_id (UUID).

deciduous diff export creates shareable JSON patches. deciduous diff apply imports them—idempotently. Same patch applied twice produces no duplicates. The sync model was later extended with an event-log system for fully asynchronous team workflows.

Node #880 drove a full terminal UI with ratatui—collapsible nodes, detail panels, keyboard navigation. The observation at #199 that ratatui uses a TEA pattern (Model/Update/View) made the architecture testable.

The graph kept growing. Decision #399 tackled types unification—making the TypeScript web viewer types match the Rust Diesel ORM schema exactly. By year's end: 500+ nodes, a TUI, a web viewer, and a sync system.

The breakout idea: what if you could point deciduous at any existing project and build a decision graph retroactively from its git history?

Three skills were created: pulse (map current design as decisions), narratives (track how subsystems evolved), and archaeology (transform narratives into graph structure). The /decision-graph command tied them together—read commits, trace narratives, build backdated nodes.

To capture pivots in a project's history, a new node type was needed:

The revisit captures: what is being reconsidered, why, and connects old approaches to new. deciduous archaeology pivot atomically creates an observation, revisit, and new decision—three nodes, three edges, and marks the old node superseded. One command.

To prove the archaeology concept, deciduous was used to graph ripgrep's 10-year design evolution. The result: 107 nodes across 7 major narratives—glob/ignore crate evolution (#1068), terminal coloring (#1090), file type system (#1104), PCRE2 integration (#1116), and more.

Each narrative traced a real design arc. Node #1083 captured a genuine pivot: ripgrep switched from breadth-first to depth-first directory traversal after discovering 1GB memory usage in wide directory trees. The archaeology skill found the evidence in real commit messages.

With 1,000+ nodes, the old web viewer was overwhelmed. A complete redesign followed.

Smart narrative detection filtered to significant 10+ node trees. D3 DAG flowcharts replaced force-directed graphs. Full-text search with FTS5. Resizable panels. Card-stack archaeology view with keyboard navigation (j/k/g/G/Space). The Q&A interface let users ask questions in plain English, grounded in the graph.

Decisions don't exist in isolation. They come from screenshots, architecture diagrams, Slack threads, spec PDFs. v0.13.0 added document attachments:

• 7 doc subcommands: attach, list, show, describe, open, detach, gc
• AI-generated descriptions for searchability (--ai-describe)
• Content-hash deduplication with soft-delete and garbage collection
• REST API: /api/documents endpoints for the web viewer

Multi-assistant support followed: Windsurf, OpenCode, and Codex all work alongside Claude Code. deciduous init --windsurf, --opencode, --codex.

After watching how the graph grew over 77 days, the canonical flow became clear: goals lead to options, options lead to decisions, decisions lead to actions, actions lead to outcomes. Observations attach anywhere. Revisits connect old approaches to new. This wasn't imposed top-down—it emerged from 1,175 real nodes.

The graph breaks down into: 144 goals, 126 options, 103 decisions, 391 actions, 246 outcomes, 160 observations, and 5 revisit nodes. 9 slash commands and 3 skills are bootstrapped by deciduous init. The web viewer runs at deciduous serve with DAG, timeline, archaeology, and Q&A views.