What I mean by The Mesh

I've mentioned The Mesh in nearly every post I've written here and never properly said what it is. So I finally made a page that does, at t15n.io/the-mesh. That page is the short version. What follows here is the longer one: where it came from, what it is, and the ideas underneath it.

I didn't set out to build The Mesh. It grew out of how we started working. Over a few months the team at Smplrspace moved to Claude as our default thinking partner, not just for code but for the real thinking, the decisions and plans, and writing that used to live in scattered docs. The same practical problems kept surfacing. How do you carry the right context from one session into the next instead of rebuilding it every morning. How do you hand what you worked out to someone who was never in the conversation. Good thinking kept happening in a chat window and stayed there.

Around the same time, a couple of articles named what I'd been circling. Margaret-Anne Storey, Professor of Computer Science at the University of Victoria, gave a word to the failure I kept seeing: cognitive debt, work that records what a team decided and loses why. Linear's CEO Karri Saarinen argued in "design is about understanding, not output" that the thinking which produces the work is the part that matters. I read that one twice, and when I gave the team the talk on working with Claude well, I opened with it. Both pointed at the same fix: nudge the work toward capturing understanding, not just producing output.

The Mesh is built on one conviction. When AI makes polished output close to free, the output stops being the valuable part, and the understanding behind it, the reasoning a session produced, is what still has value and what compounds across a team. Lose it and you accumulate cognitive debt, a tidy wiki full of conclusions nobody can reconstruct. So The Mesh is a shared knowledge base built to keep the reasoning, not just the result, a durable and addressable place where the thinking from working with AI gets written down and found again: by me next week, by a teammate, by an agent loading context before it starts on a related piece of work. That durable layer is what I mean by a substrate. It isn't a wiki with an assistant bolted on, and it isn't a chat tool that happens to remember.

Storing the reasoning isn't enough by itself. A place to put thinking is only ever as good as the thinking that goes into it. On its own, AI drifts toward writing that's competent and plausible but with nothing specific to the team, something I wrote about in Where taste drops out. So The Mesh carries a point of view and incorporates it at the moment of writing. It comes with its own opinion about what good knowledge work looks like, how to capture understanding, when to push back, what to leave out, and the team can layer its own voice on top. This constitutes a brief, fed to the agent every time it writes, present as the work is written rather than filed on a wiki page nobody opens.

What this looks like in practice can be surprising. There's no text editor in The Mesh, and there will never be. You don't type into a page. You tell an agent what you want, and it writes on your behalf, and before it can write it has to read the brief. That single requirement, every write passing through an agent that has read the point of view first, is what makes the opinion show up in the work. Three parties end up authoring every page: the author, the agent, and The Mesh.

That reopens a question I'd thought was settled: which format to write in. I'm a fan of Markdown, and I reach for it constantly. But a key advantage is that it's easy for a human to write, and that ease has cost us the ability to express ideas visually. The moment we stop writing by hand, that cost stops being worth paying. In the early days of building The Mesh, I read a piece by Anthropic's Thariq Shihipar on the unreasonable effectiveness of HTML, and it resonated. So in The Mesh the canonical form is HTML, with real tables, diagrams, layout, elements you can actually interact with, because the arrangement of an idea is part of the idea and not decoration laid over it. The agent reads the Markdown derived from it, which is far cheaper. Writing HTML costs more than Markdown, but writing happens once and reading happens constantly, so paying more at write time is worth it when what you get in exchange is rich, visual content laid out for people to read.

There's an objection to letting an agent do the writing: can you trust what comes out? It's the same question that hung over AI and code a couple of years ago, and code is one of the first areas AI got trusted in, which is odd, because it's unforgiving and a wrong line can take a product down. Several things made it possible, all of them partly true: you can run a quick test to see whether code works, there's an enormous, publicly available corpus of it for models to train on, it's a formal medium with little ambiguity, and developers are known early adopters, used to beta software. Those are all about whether AI could be good at code, though, not whether you'd trust it on real work. The reason I find relevant in the context of The Mesh is that code already had a net. Every change is a diff you can read, it gets reviewed before it ships, it's versioned so a bad change can be rolled back, and it's attributed so you know who made it. The ecosystem around code was already used to onboarding junior developers who might not be great at first, so when agents arrived, it was ready for their mistakes too. The trust was never really in the agent, it was in the net around the work. Most knowledge work has no such net, and The Mesh is an attempt to give it one, a substrate that's versioned, reviewable, and attributable, so an agent can be let into the thinking without anyone losing the ability to catch it when it's wrong. Some of that net runs today, and the rest I'm still building.

Review is the part of that net I spend the most time in. Authoring happens in a session where I watch the page take shape, a live preview of the actual rendered result rather than a wall of markup. I'm not really writing the page, I'm seeing what I'm getting and reacting to it. When something's wrong I point at the section and the change is scoped to it, so the agent reworks that part and leaves the rest exactly as written, and the document doesn't drift while my attention is elsewhere. The work moves from writing to reviewing and iterating. That's where the judgment happens, and the accountability is mine, something I got into in The colleague I can't blame.

A few honest things about what The Mesh is and isn't. It's in real use at Smplrspace, not as a demonstration but as the place the team actually thinks now. It isn't a product, nothing to sign up for, and at this point it's more of an experiment in understanding how this new way of working can be better. It isn't open source, because I'm not sure where it's going yet. I built it because we needed it, and I'm writing about it because the ideas underneath it are worth talking through in the open.

One thread runs through everything I've written here. The thinking, not the output, is the part worth keeping, and keeping it well turns out to be a design problem rather than a storage one. The Mesh is my answer to that so far, and I'd like to hear other people's. If your team works with AI every day, what happens to the understanding when the session ends and the tab closes? And if you're putting an agent layer on a product of your own, how are you keeping its output sounding like you and not like everyone else? Those are the conversations I'd most like to have.