Building Tessera, a thinking layer for AI builders

Outcomes

The problem

The idea for Tessera took shape during my initial experiences prototyping with AI builders. I was building various ideas with Codex, Google AI Studio, and Claude Code, and after going down several rabbit holes, the same three problems kept showing up. First, the ideas kept drifting. The longer a build ran, the further it wandered from the original intent, and I spent a fair amount of time re-explaining myself. Second, the AI consistently made up details to fit the goal. Some made sense, some had no reason to exist, and plenty of them could not be traced back to my product thinking or my prompts. And lastly, I tried to fix the first two problems by creating context files. The files helped with memory but were hard to traverse and maintain, and they eventually bloated.

That third observation was the seed. If the context is the product thinking, it deserves better than a text file.

Discovery and validation

A month into building, I tested the thesis in public. Colleagues had already confirmed pieces of what I was seeing, so I wrote about the pattern on LinkedIn, without mentioning Tessera, so the reaction would measure the problem and not a pitch: people were using AI to prototype faster and inadvertently skipping the product thinking, outsourcing it to the machine with no way to fully understand why it made a certain decision. The post struck a nerve: 1,954 reactions, 141 comments, and 127,000 impressions, with 99% of that reach coming from beyond my own network. Strangers were feeling the same loss. The assumptions held, and I kept building.

Why a model, not a document

The bet is that the fix belongs upstream of the prompt, and that it is a model, not a document. A document cannot fully capture the relationships between the parts of a product the way a model can. A model can also serve up exactly the parts relevant to a query instead of loading an entire spec, which matters more as the model becomes something an agent consults rather than a file it reads once.

So Tessera keeps the thinking as a connected model: personas, goals, problems, research, flows, tasks, screens, decisions, each linked to the inputs it came from. The agent receives the graph, not a summary of it.

The kickoff

The kickoff workflow was not always a conversation. The first version generated the model straight from the prompt without any further questions. A tester told me it was a lot to review and confirm all at once, and asked where some of the assumptions had come from. That question pointed right at the problem I was still failing to solve: the AI was making assumptions and taking over the product thinking instead of being a product partner. First, I added explicit provenance to the model so the user could see where each part came from. And second, I pivoted generation into a conversation where the AI names the questions it has about the supplied material, explains what it understood, and asks the user to validate or correct it.

Each card now shows its reasoning in full: what it read, what it weighed, and the option it leans toward, labeled as a lean and framed to be pushed back on. The user can pick an alternative, correct an earlier answer, or skip, and a skipped question gets logged as unknown instead of guessed. The right rail keeps score honestly. The model outline builds as the conversation runs, every row tagged with how it got there: discussed, from you, or inferred. Progress reads as coverage of the model, not length of the transcript.

The workspace

The workspace is where the co-authored model becomes the user’s to shape. Cards for personas, problems, tasks, constraints, flows, entities, research, decisions, and goals sit in one grid with three ways to read it: compact, expanded, and a map. The filters surface what needs attention first: open issues, and the fields the AI inferred, so the user can get right to any inference and update or confirm it.

The cards themselves went through a correction. At first, they were all expanded and editable in place, which made the cards longer and harder to scan, and they tested badly. Some editing, like relationships, still had to happen in a detail view, so the model had two editing homes, and in-place fields limited where a click could open the card at all. Moving all editing into the detail panel simplified the card face, made it easier to scan, and let the user click anywhere on a card to open it.

Provenance

Most AI tools are black boxes; Tessera is tagged. Every field in the model carries its source: from the user directly, from an uploaded document, from the conversation, or inferred by the AI. From-you reads green and inferred reads sky, so a card can be scanned for exactly what the user authored and what deserves a closer look before anything gets built on it. And “I don’t know” is a first-class value: better than blank, because it records that the user was asked and didn’t know, instead of letting the system quietly fill the gap on its own.

The map

The graph view was the first thing I built and the thing I was proudest of. Early users were confused by it. They wanted to map every relationship from that view, and they couldn’t, because some relationships live behind the scenes. It was an advanced editing surface without an advanced audience yet. I reduced it to a read-only map, orientation rather than authoring, with room to grow back into editing when the model needs the advanced mapping features.

The build package

The export is a build package, not a copy-paste document. It carries the model summary and a readiness score, with starter prompts tuned to where the code gets written: Claude Code, Cursor, Codex, or a copy target like Bolt, v0, or Lovable. One beta tester, after running a first build from the package: “I feel like this would save me a lot of extra credits from re-prompting.” The build had landed closer to what they wanted on the first try, because the thinking arrived with the prompt.

Export is also the next thing to change. With MCP coming next, instead of a one-and-done export, users will connect to the model live, so as the product model updates, their context updates with it.

Key takeaways

Tessera is early, and the honest version of the outcomes is small. A handful of beta testers so far, not yet very active, because the beta hasn’t had my full attention and the marketing work is still ahead of me. The validation that counts so far sits upstream: the 1,900 people who reacted to the problem, and the first tester who felt the difference in a single build.

The lessons so far rhyme with my client work. The best parts of the product came from users failing in front of me: provenance exists because someone couldn’t trace a claim, the conversation exists because a wall of generated model was too much to trust at once, and the map got simpler because its ambition outran its audience. Ship the simple version first and let the model earn the advanced one.

Building solo with an AI engineering agent held up. The thinking and the craft stayed mine, and the bottleneck stayed exactly where Tessera bets it is: in the context.

Next steps

MCP is next on the roadmap, and after that, generation speed. Building the model currently takes too long, so the plan is to generate it in parallel while the user works through the conversation.