How this journal gets written.

Every entry in this journal carries a small line under the byline that says “AI-drafted, founder-edited.” If you clicked it, it brought you here. I put it there on purpose, as a standing disclosure, because I’d rather tell you how the sausage is made than have you assume I’m hand-writing thousands of words a week while also running the company alone. I’m not. There’s a pipeline, and since this is the AI track where I get to show the whole recipe, this entry is that pipeline written down.

The short version: I feed the system the raw material of a topic, it drafts, I edit the draft out loud, and we have repeated questions and checks before it goes out the door. The longer version is more interesting, mostly because of one habit that puts more of my actual voice in here than you’d expect.

Step one: the conversation is the source material

I don’t start these from a blank page and a marketing brief. For any given topic, I’ve usually already talked it to death, in working sessions with the coding agents, in planning conversations, in the back-and-forth where I actually figured the thing out. I save those conversation histories, grouped by topic, and I paste the archives in as the raw material.

So the input to a post isn’t “write something about caching.” It’s the actual record of me building and reasoning about caching, in my own words, at the time I was doing it. The draft gets mined out of that. That’s a deliberate choice, because it means the post is downstream of the real work instead of a press release invented after the fact.

This is also where the dates come from, and I want to be plain about the dating frame because it’s the kind of thing that looks sneaky if you don’t say it out loud. The entries are dated to when the work actually shipped. But they’re often drafted later, from the records of that time: the conversation archives, the commit history, the release notes. So a post dated the week a feature shipped might have been assembled from that week’s records at a calmer moment, later. The date marks when the thing happened, not when the paragraph got typed. The primary sources are contemporaneous even when the writing isn’t, and I’d rather just tell you that up front.

Where my voice actually is

I want to be careful with the word “quote,” because most of this journal isn’t quotation. The body of an entry is blended: AI drafting, my phrasing folded in from the source conversations, my corrections dictated over the top. You won’t be able to point at a sentence and know which of us produced it, and I’m not going to pretend you can. The honest claim is smaller: as much of my voice as possible goes in while it’s being written.

Here’s the habit that makes even that smaller claim mean something. I talk into my screen. Most of my day is voice dictation, not typing. I started on a tool called SuperWhisper and these days I use one called Hex, but the point isn’t the tool, it’s the habit: the way I interact with my computer is by talking to it. When I reason out loud about why a cache key needs another dimension, or why the failure mode has to be Shopify, that reasoning lands in the archive as words I said. The drafts get built out of that record.

That’s the whole trick, and it’s kind of a boring trick, which is why I like it. Dictation makes the conversation the primary source. There’s no step where a writer imagines what the founder would say. The founder already said it, on the record, because saying things out loud is how the founder uses a computer.

Calibrating the voice

A draft mined from raw conversation is honest but shapeless. Conversation wanders, repeats itself, trails off. So there’s a register the system aims for, and it’s calibrated on the engineering blogs I actually admire and go back to: Stripe’s, Cloudflare’s, and Instagram’s engineering writing. Those share a quality I wanted here, which is that they explain a hard thing so clearly you come away feeling smarter instead of sold to.

That calibration is a rule, not a vibe. Patient over punchy. Define the domain term the first time it shows up so a reader who doesn’t live in this stack never feels reached over. Numbers stated plainly, in passing, not staged for applause. No mic-drop closers, no breathless adjectives, and no em dashes, which I’ve somehow developed strong feelings about. The aim is a smart person explaining something to a friend, not a company announcing something.

The draft, then the mic goes back on

The system produces a first draft against all of that. And then the most important step happens, which is that I read the whole thing out loud with the microphone open.

This is not proofreading. As I read, I’m talking through the changes: this bit sounds too confident, I actually wasn’t sure about that; this is missing the reason we went the other way first; that’s not how I’d say it. More often than not I’m taking a specific sentence and restructuring it, because a fact check says it’s different, or because I want a different tone, a different joke, a different reference. My fingerprints end up all over the entry that way. And because the mic is open, all of that commentary goes straight back in as more of my own words. So the editing pass is itself another round of dictated conversation, which becomes more source material. The personality gets inserted live, because it’s the same person talking into the same screen.

That’s the part I’d defend hardest if someone called this an AI-written blog. The draft is AI-generated. The judgment about what’s true, what’s overstated, what’s missing, and what sounds like me is mine, applied out loud, every entry. AI-drafted, founder-edited, exactly as the byline says.

Due diligence

Before anything publishes, we check it, the way any blog worth reading should. Numbers trace back to something real, the repo, the commit history, the release notes, and if a number can’t be traced, it doesn’t go in. No invented statistics. The reason is plain enough: the credibility of this journal rests on the numbers being real, and integrity is one of the values the company actually runs on.

The byline, and the fact that this is recursive

Which brings me back to the little line itself. “AI-drafted, founder-edited” sits under the byline of every entry, on purpose, and it links here, because a label that small mostly raises questions and this page is where I answer them properly. It’s not a hedge and it’s not false modesty. It’s the accurate description of a process I’d rather show than hide, because the alternative is letting you assume something that isn’t true and calling that marketing.

And I should close the loop, because it would be a little absurd not to. This entry, the one you’re reading about how the journal gets written, was written that exact way. It started as pasted conversation about the pipeline. The phrasing and the asides came out of things I said out loud. The draft got read back with the mic open and edited live in my own voice. The claims got checked. Then it published under the same byline as everything else.

So if you want to know whether the process described here actually produces what you’re looking at: you’re looking at the proof. It’s the process, describing itself, run on itself.

The next AI-track entries get more concrete about the machinery upstream of all this, the agents that write most of the code the journal is about, and where that whole operation runs once it stops living on my laptop.