The most natural input already exists in human behavior. The system's job is to start there — not teach you where it needs you to be.

There is a particular kind of frustration that doesn't come from lack of ideas. It comes from the gap between having an idea and being able to do anything with it. A half-formed thought at midnight that connects something I read three weeks ago to a problem I'm stuck on today. The moment I reach for a tool to hold it, the connection slips. The friction of organizing — deciding where it goes, what it belongs to, how it relates to everything else — is enough to dissolve what was already fragile.

Most productivity tools are built on an assumption so obvious it goes unexamined: that structure is something the user provides, and the tool holds. But thinking doesn't work that way. Not for everyone. For people with ADHD, the cognitive overhead of managing a tool is not a minor inconvenience — it's the thing that makes thinking feel impossible. Research shows that for people sensitive to interstitial friction, a single context switch can take up to 15 minutes to recover from. The average neurotypical person recovers in under 10 seconds.

I am one of those people. Which gave me a personal stake in the question: what would a tool look like if structure emerged from the thinking — instead of the thinking being bent around the structure?

I spent two weeks doing what I call behavior archaeology — not surveying users with questionnaires, but watching myself and other non-linear thinkers in their actual environments. Screenshotting my own desktop at random intervals. Journaling where ideas actually lived versus where I intended them to live. Talking to designers, writers, and researchers about the systems they'd tried and why each one had eventually failed them.

Three patterns emerged.

The Capture Problem. Ideas get captured in whatever surface is nearest — a DM to yourself, a voice memo, a note that will outlast its context. The choice is always: slow down and file it correctly, or catch it now and deal with filing later. Later never comes. Speed of capture beats quality of storage, every time.

The Connection Problem. This was the deeper one. Ideas that belong together live in different places — a note from six weeks ago directly relevant to today, a decision from a previous session that reframes something you're about to commit to. Non-linear thinkers don't think in silos, but every tool stores things in silos. The connections that would help you move forward never surface, because nothing is watching for them.

The Forward Motion Problem. Most tools are good at holding things. Almost none are good at helping you move. "What should I do next?" is rarely answerable from inside a Notion database. The structure is there, but it's inert. It doesn't think with you. It waits.

The problem isn't storage. It's momentum. People don't need a better place to put things — they need something that helps them keep going.

The first version of Flowd was built around a freeform spatial board. Cards of different types — notes, decisions, documents — scattered across an open canvas, draggable, repositionable, owned entirely by the user. The AI lived at the edges: a chat drawer collapsed against the side, and a NOW tab that generated an AI-organized synthesis of what existed on the canvas.

The logic held on paper. The board as the primary thinking surface. The AI as interpreter, reading what the user had built and reflecting it back. I built it in React with a live Claude API integration — real drag behaviors, real card types, real AI responses — and used it every day for three weeks.

The NOW view was the tell.

NOW was genuinely useful when returning to a project after a break. But it was a read surface, not a working surface. You landed there to orient, then switched to the board to do anything. Two modes. Two mental contexts. A seam running through every session.

Before the full pivot, I tried a middle version: removed freeform drag, snapped cards into a horizontal scroll container by workstream. More legible, less spatially demanding. But the interaction model was unchanged. The board was still the primary surface. The user was still the one deciding what went where. Tidier does not mean automatic.

The board was asking me to organize in order to create. But organizing and creating are competing states of mind.

I had been treating the symptom, not the cause. The problem wasn't that the board was spatially chaotic. The problem was that the board required the user to be its curator — and curating is not thinking. For a non-linear thinker, the moment the tool demands curation, it becomes the reason you leave. Not because you're lazy. Because the cognitive cost of switching into organizational mode while in creative mode is genuinely prohibitive.

My breakthrough came when I stopped asking how to improve the board and started asking whether the board should be the primary surface at all.

Every version of Flowd had inherited the same assumption from the tools I was trying to replace: that structure is the product, and thinking is what you do to fill it. The board is the destination. The conversation is the road to get there.

What if that was exactly backwards?

The most alive moments in Flowd were never on the board. They were in the chat drawer — when a thought was forming in real time, when a question led somewhere unexpected, when the AI pushed back and a better idea emerged from that friction. The board was where thinking went to be preserved. The conversation was where thinking was actually happening.

So: invert it. What if the user just talked — ideas, decisions, questions, things found, things completed — and an AI agent listened, thought alongside them, and built the board from the conversation in real time? The board becomes output, not workspace. It builds itself while you think. The user never curates it.

Conversation is the input. The board is the output. They happen simultaneously, side by side.

The closest feeling: a very smart collaborator who has read everything, remembers everything, and keeps the project organized while you talk. No mode switching. No curation. You think out loud. The system keeps up.

One view.

Flowd v1 had three surfaces — THE SPACE, NOW, and a collapsed chat drawer. Three mental models. A mode switch before a single thought was captured.

Every additional surface is a tax on attention. For non-linear thinkers, that tax compounds fast. The goal is a system that responds fluidly to the intentions of its user, rather than asking people to modify their thinking around arbitrary containers. Each view I cut was a step toward that. One view is the answer: the fewer modes a product has, the more cognitive space is left for actual thinking.

The interface is deliberately quiet. Chat and workspace, side by side. Chat is wider — not a visual accident but a signal: this is the primary entry point. The board lives in the right column. Always visible, always current, never demanding. You don't navigate to it. You glance at it.

What is complex is what the AI is doing while you work.

Recognition. The AI reads the conversation not just to respond, but to understand. When a topic shifts, when a new idea connects to something from three sessions ago, when a decision is being made — the AI recognizes these patterns and acts on them. This is the connection engine that every previous version lacked.

Materialization. When recognition fires, content appears on the board — softly. Cards materialize without interrupting the conversation. The board grows at the periphery of attention, not in the center of it. The experience: the system is quietly keeping up.

Contextual Continuity. Because the AI has read everything, it can always hold the implicit question underneath any conversation: where are we, and what matters right now? Not search. Not a summary. Active awareness of what's unresolved, surfaced without being asked.

SOUL.md is a character specification for Flowd's AI — not what it can do, but how it should be.

Writing it forced me to articulate something that had been implicit throughout the entire design process: the AI in this product is not a feature. It is a collaborator. And collaborators need a defined perspective — not just capabilities.

A collaborator without perspective is autocomplete. A collaborator with the right perspective is why you trust the product.

When should the AI speak versus stay quiet? When has it earned the right to reorganize something? How does it hold uncertainty without breaking the user's confidence in it? These are not engineering questions. They are design questions. They have to be answered before a single line of logic is written.

The core experience — a conversation that builds structure in real time, connections surfacing that the user didn't request — only reveals itself when the AI is actually running. Static screens cannot show what it feels like when a workstream appears at the edge of your attention without you placing it there.

Every significant design decision was made inside a live prototype. React throughout — useState for conversation state, component-level props for board card generation, live Claude API calls for the recognition engine. The code was a design instrument, not a deliverable.

This forced a discipline that static tools don't require: every state has to be reachable. You cannot draw an edge case and skip its behavior. If I wanted to design the moment where the AI is uncertain — where recognition might misfire — I had to build the condition that triggers it, then design into that condition.

The edge case is where trust is either built or broken. It is not optional.