Switchback: Browser History for Your Thoughts

I just had one of those ideas that feels simultaneously obvious and novel. An app called Switchback - like browser history, but for chains of reasoning.

The core concept: a doubly linked list where each node is a thought, and you can navigate forward and backward through the chain. World of Goo meets mindmap meets TODO list.

The Meta Part

Writing this post IS the first use case. Here's the actual reasoning chain that led here:

"I need a new project folder"
  ↓
"I should improve my project folder creation"
  ↓
"Add it to my towles-tool CLI"
  ↓
"Wait, make a Claude plugin instead"
  ↓
"Easier to share - skill or command?"
  ↓
"Make /tt:one-off that creates one-offs/2025/2025-12-05"
  ↓
"Actually, this pattern is the real project"
  ↓
"Call it Switchback"
  ↓
"Write a blog post to think through it"

Each arrow is a context switch. Each node is a perfectly-sized task for an AI agent. The chain gives full context.

Why Doubly Linked Lists?

This is the data structure but never had a good excuse for.

interface ReasonNode {
  id: string
  content: string
  prev: ReasonNode | null
  next: ReasonNode | null
  timestamp: Date
  chain: 'work' | 'dad' | 'house' | string
}

Navigate forward: "What did this lead to?" Navigate backward: "Why was I thinking about this?"

i'm wondering if could build a minimal web app around this structure. Simple UI to add nodes, navigate chains, tag them.

Multiple Chains

The killer feature: multiple independent chains running simultaneously.

My work chain might be: "Fix bug → Review PR → Deploy → Monitor metrics"

My dad chain: "Soccer practice → Buy cleats → Register for spring league"

My house chain: "Leaky faucet → YouTube tutorial → Hardware store → Actually call plumber"

Each chain is isolated. No mixing contexts. No overwhelming single TODO list.

Stream of Consciousness Capture

The hardest part of task management isn't doing tasks. It's capturing them without breaking flow.

Switchback would let me dump thoughts rapid-fire:

"Need to update DNS" → New node, work chain

"Kids need new backpacks" → New node, dad chain

"Blog post idea about reasoning chains" → New node, meta chain

The chain structure preserves context automatically. Each node knows why it exists.

From Thought to Task

Here's where it gets practical. Each node in the chain could become:

• A task for an AI agent (with full context from the chain)
• A calendar event
• A note to my future self
• Nothing - just a recorded thought

The chain itself tells the story. The agent can traverse backward to understand "why" before executing "what."

What I Don't Know Yet

This is conceptual. I haven't built it. I'm thinking out loud.

Open questions:

• How do chains merge or split?
• What happens to abandoned chains?
• Do chains need tagging beyond just the name?
• Is this just a fancy linked list that nobody needs?

Writing this post is part of figuring it out.

Why This Might Matter

Most task apps assume tasks are independent units. They're not. Tasks have context chains.

Most note apps assume notes are documents. They're not. They're nodes in reasoning graphs.

Switchback sits in the middle. Lightweight enough to capture thoughts. Structured enough to become action.

Next Steps

I might build this. I might not.

But I'll definitely use the reasoning chain from this post. That chain is already valuable - it captured the evolution from "I need a folder" to "I need an app."

The doubly linked list preserved the context. I can navigate back to any decision point and ask "why did I think this?"

That's the test. If the tool helps me understand my own thinking better, it's worth building.

The project folder for this idea? one-offs/2025/2025-12-05/switchback

Created automatically by the /tt:one-off command I built while thinking about this problem.

Meta all the way down.