Rabbit Hole

AI conversations are linear. Your thinking isn’t. Rabbit Hole makes the path visible. Turn AI conversations into visible paths you can branch, revisit, and build from.

Comment

Inspiration

Hi! My name is Katie O'Daniel. I'm a graduating senior at Purdue, currently looking for software engineering work somewhere outside the Midwest (˶˃𐃷˂˶), and when I'm stressed, I like turn that energy into creativity. Sometimes it's my personal website, dashboards, Minecraft mods and platforms that did not need to become an entire platform when I first thought of it. You can probably tell from my GitHub contributions between March 25 and June 3.

I really like design, but I've realized that I might like planning even more. I love sitting down with an idea and figuring out what it could become: what features should it have, who is actually going to use it, what am I missing, and is there a completely different direction that would make more sense? This is also where I get myself into trouble, because one feature becomes three more, then one of those makes me rethink the first feature, and eventually I am scrolling twenty messages back trying to find an idea I had earlier.

A recent example was another project I have been working on: a website and platform for adoptees. Originally, I was going to build it specifically for Chinese adoptees. That made sense to me because it was close to my own experience and it was where I started. But as I researched more, thought about what the community should actually be, and tried to understand perspectives outside my own, and through that, the idea changed. I realized there were experiences that were specific to Chinese adoptees, but there were also much bigger conversations around adoption, identity, belonging, family, culture, and growing up between different worlds.

That experience is a big part of why I made Rabbit Hole. I use AI constantly when I plan projects. I use it to brainstorm features, research questions, argue against my own ideas, compare approaches, and figure out what I might not be considering. But all of that usually ends up in one giant conversation. I can scroll back and find an old idea, but I can't really see the moment when my thinking changed, the branches I almost followed, or why I stopped following one direction and chose another.

At some point I thought: What if I could actually see the rabbit hole?

So I built it.

What it does

Rabbit Hole takes all of that messy exploration and turns it into something you can actually see. You start with a question or an idea, and from there you can explore different directions, go deeper into one path, branch somewhere else, add your own thought, or go back to something you were considering earlier. I also did not want the directions you skipped to just disappear, because sometimes an idea that did not make sense at first becomes useful again later.

Rabbit Hole currently has two main modes: Investigate and Design. Investigate is for research and questions. Instead of asking AI for one big answer and stopping there, you can follow different perspectives, look at evidence, question what you are finding, and keep exploring as the original question changes. You decide what is worth keeping, and eventually that path can become an Investigation Brief that shows where you went, what evidence mattered, what complicated the question, and what is still uncertain.

Design came more directly from how I build things myself. I rarely start with a completely planned product. Usually I start with something like, "I want to make a platform for this," and then I spend way too much time figuring out what that platform should actually be. Design gives you a place to explore those different versions before committing to one. You can try different directions, branch when a new feature changes the idea, go back to something you liked earlier, and eventually create an outcome from the decisions you actually chose to keep.

The two modes are different, but they are really solving the same problem for me. Whether I am researching something or designing something, I almost never get to the final direction in a straight line.

How I used WebMCP

WebMCP is what lets Rabbit Hole expose the workspace to an agent in a structured way instead of making the agent guess what is happening from the visual interface.

Rabbit Hole registers WebMCP tools that let a compatible agent inspect the current state of an exploration. That includes things like whether the user is in Investigate or Design, which node is currently active, the path of nodes that led to it, what the user has decided to keep, what branches are still available, and how sources and evidence connect to the investigation.

That is useful because the graph itself contains information that would normally be difficult for an agent to understand just by looking at the page. If I am five branches deep into an investigation, the agent does not have to rely only on the last prompt I typed. It can understand the structure that led me there.

I also use WebMCP to separate understanding the workspace from changing it. An agent can inspect the current Rabbit Hole and use that context to suggest a next direction, but a suggestion does not automatically become part of the graph. The user still chooses whether to follow it, keep it, or go somewhere else.

For me, that is the main reason WebMCP fits Rabbit Hole. The product is already about preserving context, decisions, branches, and where an idea came from. WebMCP gives an agent access to that same structure, so the person and the agent can work from the same understanding of the exploration instead of starting over with every new prompt.

How I built it

Rabbit Hole is built with Next.js, React, TypeScript, React Flow, Tailwind CSS, and WebMCP. Once I had the basic idea, I started breaking the product into individual functions and asking what each one actually needed to do.

I planned out things like how a branch should work, what should happen when someone follows a direction, what counts as something worth keeping, how sources should connect back to claims, how the different node types should behave, and how Investigate and Design could use the same overall structure without feeling like the exact same experience.

For each part, I usually brainstormed different options with ChatGPT before building it. I would ask for different ways a feature could work, try to look at it from another perspective, and then decide which direction made the most sense for Rabbit Hole. Once I had a feature in mind, I would often generate mock images of what the interface could look like and iterate on those before actually implementing it.

After that, I used Codex to help turn those plans into the working product. The process was definitely not linear. I built features, tested them, realized some were too complicated, removed them, and sometimes came back to an earlier idea with a completely different approach.

The graph itself also became more complex than I expected. I did not want every node to just be another AI response. A node might represent a question, a direction, a claim, evidence, a limitation, another perspective, or something the user added themselves. I also wanted a clear difference between something AI suggested and something the person actually decided mattered, so suggested paths stay provisional until the user chooses to follow or keep them.

For Investigate, I also had to think about the difference between having a source and actually proving a claim. Rabbit Hole keeps track of source relationships, evidence state, provenance, and uncertainty instead of treating a citation as automatic proof.

I also built pre-made examples for both Investigate and Design so someone can understand the product without needing my API key or spending money just to try it. That ended up being useful for the demo too, because someone can open Rabbit Hole and immediately see how a completed path works.

Challenges I ran into

Honestly, there were a lot. The biggest problem was that every time I answered one design question, I created two more. What is actually a branch? When should an AI suggestion become part of someone's trail? What happens to the paths someone does not choose? Should a sourced claim look different from an AI-generated direction? What happens when two sources disagree? How much context should an agent be able to inspect? How do I make sure the agent does not silently change someone's work?

And then there was the graph itself. Graphs look really cool until you have twenty nodes and suddenly everything is lines. I tried a lot of layouts, changed node shapes, added things, removed them, and rebuilt parts of the workspace because I had made them too complicated. I probably spent an unreasonable amount of time deciding how a line between two boxes should look. At some point I realized that building Rabbit Hole had itself become a rabbit hole, which felt right.

Accomplishments that I am proud of

I think what I am most proud of is how far Rabbit Hole came in such a short amount of time. About a week ago, this was basically a random idea I had for the hackathon. I remember thinking that the name Rabbit Hole fit almost too well with how I already use AI, plan projects, and constantly branch into different directions.

I have made a lot of dashboards, websites, and platforms, and Rabbit Hole is probably not the most visually impressive thing I have ever designed. My personal website still wins that category. But functionally, I think this is one of the coolest things I have built.

There is a lot happening behind what looks like a graph. The branching, node types, sources, different modes, WebMCP context, and the way the user still controls what becomes part of the trail all took a lot of planning and a lot of pivots.

I changed directions constantly while building it. Some features stayed, some disappeared, and some came back in a different form. That is probably part of why I am so proud of it now. I also hope Rabbit Hole becomes something I can show hiring managers and actually walk through with them. Not just as a finished project, but as an example of how I think, how I plan, how I change direction when something is not working, and how I keep building until an idea starts to make sense.

What I learned

I used Codex a lot while building Rabbit Hole, and one thing I learned pretty quickly is that having AI help you build faster does not necessarily mean you make decisions faster. I had a lot of different directions I could take the product, and I pivoted a lot. I would build something, realize it made the workspace too complicated, remove it, then sometimes go back to an idea I had several versions earlier.

That also made me think differently about how I use AI and my tokens. Sometimes I was asking Codex to build before I had really decided what I wanted. I could have saved a lot of time, prompts, and probably tokens if I had been able to lay out the different possibilities first, compare them, keep the parts I liked, and then send a much clearer direction into the build.

Ironically, Rabbit Hole would have been really useful while I was building Rabbit Hole. I could have used it to map out the different UI ideas, features, research decisions, and paths I was considering instead of having pieces of that thinking spread across long conversations.

That is something I want to keep improving. I love using AI to build quickly, but I also want to get better at deciding what is worth building before I ask AI to build it.

What's next for Rabbit Hole

There are a lot of directions I did not have time to explore. I would love to use Rabbit Hole for projects that last months instead of one session. Imagine reopening something six months later and being able to see why you made an important decision instead of only seeing the final version.

I would also love to try collaboration. If several people were exploring the same problem, it would be interesting to see who introduced a branch, which person's perspective changed the direction, and where the group disagreed.

I also keep thinking about how Rabbit Hole could work with other tools instead of trying to replace them. A design path could connect to Figma. A research path could connect to a database or knowledge base. A planning path could eventually move into whatever tool a team already uses to build. What interests me most is keeping the reasoning behind those outcomes, not just the final file.

That is also where WebMCP gets more interesting to me. If an agent can understand the decisions, rejected ideas, evidence, and current direction behind a project, then maybe that context can move with you instead of having to explain everything again every time you switch tools.

I do not know exactly where Rabbit Hole goes from here, which is probably fitting. AI is going to work alongside us more and more, and I think we are still figuring out how all of these tools should actually work together.

Rabbit Hole is one version I wanted to try.

Built With

  • chatgpt
  • codex
  • netlify
  • next.js
  • openai
  • openaiapi
  • react
  • reactflow
  • tailwindcss
  • typescript
  • vitest
  • webmcp
  • zod
Share this project:

Updates

Submission history