Preparation: not building faster, starting better

I started with Obsidian. Collect ideas, link them, let them grow. That worked well, right up to the point where the collection had to turn into something buildable. Forty notes do not become a specification on their own. I made that translation by hand every time, and it was the actual work.

Today the same work ends in a document Claude Code can start building from directly. That is the change this post is about, and it is not that I write faster.

What was missing in Obsidian?

Nothing about what it does. The problem was the split. The notes lived in one place, the conversation with the model in another, and I was the translation layer between them: I pasted excerpts into a chat window, read the answer, carried the result back. Context was lost at every jump, and what the model saw was only ever the excerpt I had picked in advance.

So I built my own tool, Thinktank. A local application where an idea is a folder of real files and Claude works on that same folder through the Agent SDK. Not as a chat partner alongside, but with access to the same body of work. The application deliberately copies no document content into the prompt. The agent reads for itself, with its own tools, and so sees everything rather than my selection.

It stays private. Too much of what I have learned over the years went into it, and it is cut too closely to my own workflow to be useful to anyone else.

How does an idea grow there?

It starts with one sentence. After that everything that turns up over time gets added, not as a note about the thing but as the thing itself: I drag client feedback into the chat, a research finding, a PDF from a meeting, an extract from an email. The material is copied into the idea and stays intact where it came from.

Claude then works it in. Not as an attachment sitting beside everything else, but at the place in the concept where it belongs, into the documents that already exist. A pile of findings becomes a text that holds together. That is the work I used to do myself, and it is the part that always got left undone while collecting, because it is tedious.

The part I underestimated most, though, is not the answers. It is the questions back. When two inputs contradict each other, when a requirement rests on an assumption written down nowhere, when I use one word for two different things, Claude asks rather than picking a reading. A contradiction caught here costs five minutes. The same contradiction caught during implementation costs a day.

When is an idea ready?

Every idea carries a maturity level in four steps: seed, in progress, concept settled, ready to build. I am the only one who sets that step. The application does not guess it, does not infer it from size, and does not let the agent estimate it.

That was a deliberate decision, and I consider it the most important one in the whole tool. Judging whether a concept holds is precisely the work you must not hand over. A document can look complete and still rest on an assumption that is wrong. No model sees that. Only someone who knows the client does.

What comes out at the end?

A product specification, in the same folder as everything else. The agent can run OpenSpec inside the idea, and the spec artefacts emerge from the grown concept right next to the documents they came from. That is what Claude Code starts building from.

This is where the largest change is, for me. There used to be a translation between thinking and building: notes became tickets, tickets became code, and something was lost or reinvented at every step. That break is gone. What I spent weeks thinking through goes into implementation without being rewritten, and the implementation works against the same version I was thinking against.

It stays controlled all the same. The agent is confined to its own idea directory, has no tool for arbitrary shell commands, and works against a fixed allowlist. A tool that writes alongside you needs limits, the same limits I wrote about in limits instead of instructions.

What does it cost, and who should skip it?

You build a tool instead of the thing you actually care about. That only pays off if you go through this phase often. Anyone writing two concepts a year is better served by Obsidian and an open chat window, and should put the time into the concept itself.

And it does not do the thinking for you. It does the gathering, the rewriting, the tracking of contradictions. Whether the idea is right is still written down nowhere. What I gain is the number of passes I can afford before the first line of code exists, and a start that rests on something thought through rather than on a pile of notes. That is the same thought as in agentic engineering: not making the model better, but building the frame so its work lands where it counts.