Think, Plan, Build modes

Think of it like planning a trip before you start driving. Think is the conversation where you figure out where you actually want to go. You talk it through with an AI thought partner (Sparkle calls it the "Chief"), and the important part is this: while you are in Think, nothing happens to your project. No files change, no agent runs. It is a safe room to figure out what you want.

When the idea is solid, Sparkle turns it into a Plan: a tidy, ordered list of tasks (a board you can look at but not break). Then Build is where the real Claude Code agents do the typing and actually make the software. You move Think to Plan to Build, in that order, and Sparkle walks you across each step. The chevrons at the top of the sidebar are how you switch between them.

Three modes, one chevron strip. Think () is a chat surface with the Chief that writes zero code: brainstorm, get interviewed, get challenged, shape the spec. Plan is the read-only Tasks board over your work graph. Build () is the orchestrator plus its worker agents executing that graph.

The leverage is the seam. When your spec is ready, you hand it to Build with one click and the orchestrator starts decomposing and fanning out. And it is bidirectional: a Build agent that hits an ambiguity can flag the question back to Think instead of guessing and shipping the wrong thing. So you are not babysitting a prompt that already turned into code. You shape intent in Think, watch it become a prioritized list in Plan, then turn a fleet loose in Build. Ship the right thing faster because you settled "what" before "how."

Mode is a sidebar-header toggle, not separate windows. Think is a Chief-backed chat pane: no PTY, no worktree, no git mutation, an isolated reasoning surface. Plan is a read-only view of the beads task graph. Build is the orchestrator-plus-workers runtime: each agent in its own worktree on its own branch.

The handoff is explicit. "Send to Build" reuses the project's existing Build agent (or creates one), opens its pane, and seeds it with a prompt that points at the epic and its PRD and tells it to execute the children under the beads protocol. The reverse path exists too: a Build agent can deliver a question back into the Think agent's conversation, so an open question is escalated to a human-shaped decision rather than resolved by a confident hallucination. Think mode is gated behind the paid AI enhancements; Plan and Build are not.

A PRD ("product requirements document") is just a clear write-up of what you are building and why. You do not have to write it. After you have talked the idea through in Think, you press one button and the Chief turns the whole conversation into a real, organized document: the problem, the goal, who it is for, the design, the questions still open, and what is deliberately left out. It gets saved right inside your project as a normal file, so your agents (and you) can read it later. It is the difference between "I think I want a thing" and a written plan everyone can follow.

This is the artifact that makes the rest of the build sane. One click after a Think session and you have a structured PRD (Problem, Goal, Users, Design, Open questions, Out of scope) committed into your repo under PRD/, then handed straight to the orchestrator as an epic. Your agents reference it throughout the build instead of re-deriving your intent from a one-line prompt. Spend ten minutes in Think, get a spec your fleet actually follows. That is how you stop AI from confidently building the wrong thing.

Synthesis runs Chief at research depth over the transcript, grounded in the project's existing docs, and is told to cite them as inline markdown links. Output is raw markdown: a leading # title, then the six fixed ## sections. It is written to PRD/<YYYY-MM-DD>-<slug>.md with seeded frontmatter (title, created, source, epic, tasks), and the epic is dispatched to Build. The PRD is a real file under version control, so it diffs, reviews, and travels with the branch like any other source.

You are never doing this alone. As you think out loud, two helpers work quietly in the margin. The Librarian is the one who remembers: it digs up things your project already decided or documented, so you do not accidentally re-invent or contradict yourself. The Skeptic is the friendly devil's advocate: it gently pushes back and asks "are you sure?" so weak spots show up now, while it is cheap to fix them, instead of later. You can ignore them or invite them into the chat. Either way, they make your plan stronger before anything is built.

This is your live pressure-test. The Librarian keeps you grounded in what the project already knows (prior decisions, docs, collisions) so you are not building against your own past self. The Skeptic throws the best counter-argument at your idea in real time. Pull them in when you want them. The payoff: your assumptions get challenged at the spec stage, where changing your mind costs a sentence, not a refactor. Better input, better PRD, better build.

Two background lanes, keyed per agent, recomputed each interview turn and deliberately not persisted (a stale grounding snapshot is worse than an empty one). The Librarian lane returns grounding items (terse line plus cited doc refs); the Skeptic lane returns the strongest challenge. The interview never blocks on these; they land asynchronously and you fold them in on demand. It is adversarial review wired into the spec phase, not bolted on after the code exists.

A terminal has no "thinking" place at all. Every line you type is a command that runs the instant you press Enter, so there is no safe room to figure out what you want before something happens. Sparkle gives you that room (Think), a clear plan (Plan), and only then the doing (Build). The order protects you.

In a terminal, prompt equals action: there is no surface to shape a spec before it becomes code, and definitely no "save this conversation as a PRD" button. You either think in your head and lose it, or you fire a prompt and pray. Sparkle gives thinking its own mode and turns it into a committed artifact your fleet executes against.

A terminal collapses intent and execution into one keystroke. There is no private reasoning surface, no structured spec output, no grounding lane, no adversarial reviewer, and no formal handoff between "decide" and "do." Sparkle adds all of that as modes above the terminal, which is still right there underneath doing the real work.