How I Write Blog Posts Today

I was halfway through a brainstorming session with my favorite agent when it hit me. The conversation had grown massive. Dozens of tangents, half-formed ideas, details I was sure I’d mentioned twenty minutes ago. And then the sinking feeling: the context window was getting too big. The agent was starting to repeat things I’d already said. Details were slipping.

I caught myself thinking: “There’s no way the agent can summarize all of this. Something important is going to slip through.”

Even though AI has made it much easier to generate content, I still prefer taking time to really understand what I’m trying to say. What’s the core message? What details matter? Voice mode helps here. I can think out loud, let half-formed thoughts crystallize into something real.

But that’s also where the problem starts. Long brainstorms hit context limits. That’s when the panic sets in.

So I built a workflow to handle it. It’s not fancy. It’s not revolutionary. But it works, and it means the message I’m trying to convey actually makes it through intact.

The core philosophy: start messy, organize later. Brain dump everything without worrying about structure. The system makes it safe to be exploratory first and structured second.

The workflow at a glance

Here’s the short version:

1. Start with ChatGPT Voice Mode for brain dumping (often across multiple continuation chats)
2. Export chats via a DevTools JS snippet when they get too long
3. Paste exports into a Claude Code project
4. Use Claude Code to boil everything down into structure and key points
5. Iterate on a living draft.md file

This is for developers, mostly. Also for product managers or content creators who are comfortable with basic scripting, don’t mind poking around in DevTools, and use Claude Code or similar agentic tools. If that sounds like you, keep reading.

Step 1: Voice-first idea capture

I do most of my initial brainstorming in ChatGPT’s voice mode. It’s great for capturing ideas when I’m away from my laptop. Cleaning, commuting, walking with the baby. Whenever something clicks, I can just talk through it.

My starting prompt is simple:

I’m working on a blog post. Help me brainstorm the idea into full article content. You’re in voice mode, so ask me questions one by one.

The one-question-at-a-time approach is key. It keeps the conversation focused and pulls out details I wouldn’t have thought to mention otherwise.

Sometimes the chat gets long. Really long. And at some point, I start noticing things. The agent repeats something I already told it. Or I find myself explaining the same detail twice because it seems to have forgotten.

When you use LLMs enough, develop an intuition for that.

When that happens, I don’t fight it. I ask the agent to give me a continuation prompt, something that summarizes where we are so I can pick up in a new chat. But even with a good handoff prompt, some context gets lost. Ideas from the first chat might not make it into the second. That’s where the export step comes in.

Step 2: Exporting chats

I use a tiny JavaScript snippet to extract the full conversation from ChatGPT. Open DevTools, go to the Console, paste this, and run it:

extractChatGPTContent = () => {
  allMessages = $$("[data-message-author-role]").map((el) => {
    el.scrollIntoView();
    return { role: el["dataset"]["messageAuthorRole"], text: el.innerText };
  });
  chatContent = allMessages.reduce((acc, msg) => (acc += `[${msg.role}]: ${msg.text}`));
  return chatContent;
};
content = extractChatGPTContent();
console.log(content);

The snippet scrolls through messages to ensure lazy-loaded content is captured.

Copy the output, paste it into a file. Done.

The snippet outputs each message with its role (user or assistant), formatted as plain text. Not pretty, but functional. Claude Code, and most agents really, handle it just fine.

Step 3: Claude Code setup

I create a new Claude Code project for each piece of content. Set it up as a Git repo. Version control for writing, not just code.

Exported chats go into a /raw folder as markdown files. The structure isn’t rigid. I just dump them there and work from that starting point.

For the actual writing process, I use a customized version of the content-research-writer skill.

What Claude Code produces:

• Main idea + rough structure: I ask it to boil down all the raw chats into a coherent outline
• Key points file: A separate file listing everything important, which I use as a coverage checklist
• Living draft.md: The actual draft that I keep refining

The key points file is crucial. When I’m deep in drafting, it’s easy to forget things I said during the brainstorm. The checklist keeps me honest.

Step 4: The editing loop

I keep a single draft.md file that I constantly update. No separate “version 1, version 2” files. Just one draft, always evolving.

One trick I’ve found useful: I put editorial notes inside {{comment}} blocks directly in the draft. Things like “this section feels weak” or “need a better example here.” Then I tell Claude Code to review everything while keeping the comments clearly separated from the actual content.

This way, feedback stays inline with the text it refers to, but doesn’t accidentally end up in the final version.

Tradeoffs and gotchas

I should be honest about what this doesn’t solve:

• Context limits still exist. You’re just managing them differently, not eliminating them.
• Overlap between chats. When you split a conversation, there’s inevitably some repetition. I don’t dedupe manually. I rely on Claude Code to reconcile.
• More setup. Staying in one chat is simpler. This is for when simpler stops working.
• Tool dependency. You need to be comfortable with DevTools and Claude Code. Not a huge bar, but not zero.

Wrapping up

I’ve used this exact workflow for a recent blog post. It started as a sprawling voice brainstorm, turned into multiple exported chats, and eventually became a structured draft. Nothing got lost.

The core benefit: no idea loss, plus the freedom to brain dump whenever and wherever ideas strike.

Curious what your workflow looks like, or what’s worked for you.