AI-Native Writing

A friend asked me how I write my blog, so I figured I’d write it up for those curious.

I had a clean example fresh in my mind from this morning. A post that started as a question about a single stock ended up as an essay about the hedonic treadmill — drafted, edited, and posted within an hour. The path between those two points is roughly how most of these posts get made now.

The morning

I opened a chat with Claude on my phone to think through a stock I was considering — talking out loud while I made coffee, then kept it going on a walk with my dogs. Generic investing question — nothing philosophical about it. But the conversation drifted the way conversations do when you’re not in a hurry. We moved from the specific company to what I was actually trying to do with the money. From there to what money is for in general. From there to the hedonic treadmill, which I’d been chewing on for a while as something I thought the standard personal-finance advice gets wrong.

By the time our conversation ended, I had a take I actually liked. That was the post. The conversation had done the thinking. What I needed next was to write it down and ship it.

The hand-off

The chat interface is for thinking, and most of the time I’m not even at a keyboard. I’m on my phone — talking out loud while I make coffee, walk the dogs, drive home from the gym. It’s open-ended, free-associative, comfortable with not knowing where it’s going. I’m not trying to produce anything. I’m using the model as a sparring partner to figure out what I think.

Claude Code — the CLI I use to edit my actual repo — is for executing. By the time I open it, I usually have a draft in hand or at least a clear shape in mind. I paste the draft in, ask for the frontmatter and the right directory, and start editing in short directives. Cut this clause. Tighten that paragraph. Change “pick” to “build.” When the post feels done, I tell it to ship. It commits, pushes to GitHub, Vercel picks it up, the post is live. The whole publishing pipeline is one sentence.

Why the split helps

Writing turns out to be at least two activities. There’s figuring out what you think, and there’s polishing it into something other people can read. These two phases want different conditions.

The thinking phase wants permission to be sloppy, to ramble, to follow tangents that may go nowhere. The polishing phase wants the opposite: precision, attention to the line, the willingness to cut. Doing both in a single environment with a single tool is fine. Doing them in different environments turns out to be unexpectedly clarifying. The chat is the place where I’m allowed to be loose. Claude Code is the place where I’m tight. The hand-off between them is the moment I commit to a piece — when I say to myself, OK, this is a thing, let’s actually publish it.

A lot of posts never make the hand-off. Most of my chat conversations don’t become anything. That’s also a feature. The thinking has value on its own; not all of it needs to be packaged for other people. The ones that do get packaged are the ones where something cohered hard enough that I wanted to share it.

What changed

I’ve never really considered myself a writer. Sitting down to compose an essay used to feel impossibly slow — the kind of work that took up a whole afternoon for a single paragraph I wasn’t sure was good. But I’ve always been a thinker. I love a long, drifting conversation about an idea, the kind that goes on for hours over dinner or on a walk. I’m usually mulling something over.

What’s changed isn’t that the writing got easier, exactly. It’s that the mulling got interactive. Instead of turning the same idea over alone for weeks, I have a sparring partner who can push back, hand me new information, and force me to be specific about what I actually think. It’s probably one of the most entertaining mediums that’s ever existed.

The downstream effect is that the gap between having a thought and sharing it has effectively collapsed. There isn’t really a barrier to writing anymore. The thinking is still doing the work — it always was — but now the thinking has a partner, and the artifact comes out the other end almost for free.

If you’ve ever wanted to share the things you mull over but found the writing itself prohibitive, that obstacle is gone. A long conversation and a short editing pass is enough to produce something real — a piece you can put online and point people to. The bar to having a blog has effectively dropped to the bar of having something to say.

Getting set up

The mechanics are honestly the part most people get stuck on. You need a GitHub account, a hosting provider, maybe a domain, Node.js installed, a starter template, the right CLI pointed at the right place. The exact path depends on what you already have.

Rather than write a one-size-fits-all tutorial that would be wrong for most people, I’ll just hand you the seed prompt I’d use to walk someone through this. Paste it into a chat with the model of your choice and it’ll guide you through your specific setup, in your specific order.

You're helping me set up a personal blog. I want to write posts using two
tools: a chat with you for thinking through ideas, and a CLI coding agent
(ex Claude Code) for editing and publishing the actual posts.

Walk me through the setup step by step. Start by figuring out what I
already have — GitHub account, hosting account (Vercel or similar),
domain, code editor, Node.js installed — then work through what's
missing in the right order. Don't dump the whole plan at once.

For the blog itself, default to a Next.js + MDX starter unless I tell
you I want something different. The end state I'm aiming for:

- A GitHub repo with my blog source code
- The repo auto-deploying to Vercel on every push to main
- A local clone where I can run Claude Code
- A simple convention for adding new posts (folder per post)

Be patient and explain things I might not know. After each step, confirm
I'm done before moving on. Once the setup works end-to-end, walk me
through publishing my first post: starting a Claude Code session,
drafting, editing, committing, pushing.

If you want a fuller reference for the exact stack this blog runs on, I wrote a step-by-step tutorial a while back — you can paste that alongside the prompt above to give the model a more concrete blueprint to work from.