THE THING WE BUILT:

The Draft Process

Good things take time. Like good design. Thoughtful writing. A banger of a song.

More importantly, good things often come out of bad ideas. Confusing layouts before the perfect arrangement. Half-sentences before the perfect paragraph. Mediocre melodies before the one that sticks.

Craft is not just the final artifact. It’s the trail of iteration that leads to it.

For a long time, the web had subtle ways of signaling this. A well-designed site showed care. A well-structured article showed thinking. Humans can often detect that signal in seconds — something about the spacing, the typography, the restraint. You could feel the time behind it.

But AI changes something important. When you ask an LLM to write something, the result appears all at once. There is no visible path. No evolution. No false starts. Just an artifact.

And when artifacts become cheap to generate, we lose one of the web’s oldest trust signals: the evidence that someone actually worked on something.

This matters because trust on the internet has always been partly about effort. The reason a thoughtful blog post feels different from a content-farm article is the sense that a human sat with the ideas long enough for them to develop. That temporal investment is legible, even if we can’t always articulate why.

Generated content has no temporal investment. It has no draft history, no false starts, no weeks of thinking between versions. It arrives fully formed, which is exactly what makes it feel hollow when you notice.

So we built a page that shows its own process.

Exposing the thinking that lead to this

How It Works

This page hosts an essay, but the page’s value is in its three separate layers.

The first layer is The Artifact. Here, a clean essay about process transparency. A normal reading experience. Most visitors will just read this and leave. That’s fine. Humans still need finished artifacts.

The second layer is The Thinking Timeline. Below the essay, there’s a chronological record of how the idea developed. Seven entries across eight days: from a vague note about "design as trust signal" on February 28, through the temporal insight on March 3, to the three-layer structure on March 6. Each entry is expandable. The dates serve as evidence to the real work unfolding over time. Ideas appear, sit, and come back different a few days later.

The third and final layer are “Draft Diffs.” They show how different Drafts shifted across V1, V2, and V3 of the final Artifact. Copy additions are highlighted in green. Deletions struck through in red. It’s a beefed-up version of Word’s “Track Changes” but with less chaos. Doesn’t expose the audience to the entire creative process, but builds trust by showing revision history in a thoughtful way.

Each layer adds depth. The essay is for humans who want to read. The timeline is for humans and agents who want context. The diffs are for anyone who wants evidence. Progressive disclosure. You go as deep as you want.

There’s also a machine-readable process.json block: revision count, timestamps, thinking gaps, author, sources. An agent could parse this to evaluate whether the content was likely generated or worked on over time. Not a claim about care. Evidence of work.

Notes from Building

The thinking process for this newsletter is exposed in the prototype itself. The timeline you see on the page is the actual set of notes that led to the essay. It exposes its own process. Instead of publishing only the finished piece, the page shows the intermediate steps: the early framing around design and trust, the rejected ideas, the dead ends, and the moment the “Time as a Signal” idea clicked. The notes below are the same ones used to construct that timeline. The page becomes its own proof of concept.

When the web’s primary content consumers become AI agents, perhaps revision history becomes a more reliable source of trust. While humans detect craft through feeling (e.g. spacing, typography, restraint), agents cannot feel those things. But agents can parse timestamps, count revisions, measure gaps between edits, and evaluate whether the pattern of work looks organic or instantaneous. The process page gives agents something to inspect. Not the artifact. The trail that produced it.

Expose the creative process. Version control systems like Git track every change to code, and collaborative knowledge projects like Wikipedia expose full revision histories. But those models rarely apply to published creative work in a way readers can see. This could evolve into a simple standard: a .well-known/process.json, revision metadata in HTML headers, and Git-backed publishing platforms exposing revision timelines by default. Content arrives finished, and you either trust it or you don’t. This process page proposes a third option: show the work.

Built with ❤️ by Township

You’re receiving this because you signed up for Township’s “We Built a Thing” newsletter. We'll only send these when we, well, build things.