Thinking in Threads with Bike Outliner

I’ve been looking for a tool that supports threaded thinking. Distill nails the concept: you think out loud into threads, and AI agents respond inline without breaking the flow. But it’s pricey, hosted, and not native. I want local files so I can use git.

So I built something similar with Bike.

The Threading Idea

The core concept is append-only threading. New thoughts go at the end. No reorganizing, no inserting between existing ideas. The thread keeps expanding.

This preserves how ideas actually develop. When I capture thoughts in a traditional outline, I’m constantly deciding where things go. That decision-making interrupts the thinking. With append-only, there’s no decision. New thought? Add it at the end. Want to go deeper? Indent.

I’ve written about this before in Reviewing append-only workflows. The pattern keeps showing up: Mastodon threads, chat-based note apps like Gibberish, and now Bike.

Why Bike

Bike is a macOS outliner (think Workflowy, but native and scriptable). What makes it work for threading:

Indentation for depth – Drilling into an idea by adding child rows

Sequencing – New rows extend the thread chronologically

Grouping – When patterns emerge, I can nest siblings under a new parent

The structure emerges from the content. I start typing, indent when going deeper, and the hierarchy forms naturally.

Adding AI Inline

Distill’s insight is that AI agents can watch threads and respond without being addressed directly. I wanted that for Bike.

So I built thread-watch. It watches my outlines for rows tagged with @question and adds responses as indented blockquotes. The workflow:

Think out loud in the outline

Tag uncertainties with @question

Run thread-watch (keyboard shortcut)

Responses appear as children of the question

Keep thinking, keep appending

The responses stay in the thread. They’re part of the thinking record, not a separate conversation.

Here’s what it looks like in practice:

Reactive Prompting

The technique I use for AI responses is what I call reactive prompting. The agent isn’t addressed directly. It responds to the thought stream.

The system prompt tells Claude to write like margin notes in a book: factual, terse, no “I found that…” discovery narrative. This matters because conversational AI responses feel like interruptions. Reactive responses integrate with the thinking instead.

Connecting to the Zettelkasten

The agent has access to my Zettelkasten folder. Before answering, it searches for relevant existing knowledge and links back. I was outlining something about capture workflows, tagged it @question, and the agent found a note I’d written two years ago. The response linked back, and I restructured my outline based on what past-me had already figured out.

Bike becomes the staging area for fast thinking. When something crystallizes, I copy it to the zettelkasten as a permanent note.

The Trade-Off

Append-only limits restructuring. If the structure is wrong, I can add cross-references and synthesis rows, but I can’t reorganize without losing the thinking record.

Tagging @question and running the tool is still an interruption. It’s smaller than switching to a chat window, but not invisible.

Why This Works

Standard outlining is about organization. Threading is about capture. I’m not building a perfect structure. I’m externalizing thinking fast enough that I don’t lose it, and the AI assists inline when I need context.

The structure emerges. The thread keeps expanding.