Blogging in 2025

I want blogging to feel effortless and creative—something closer to collaborating on ideas with a co-founder. Something that frees me up to spend my limited energy on brainstorming, taking notes, and crystalizing powerful ideas.

In theory, AI should finally allow us to stop worrying so much about grammar, structure, and formatting. It should give us a blogging experience a bit like "vibe coding" (If you need it, here's an overview on vibe coding by @MatthewBerman).

And yet… here in 2025, it's still incredibly frustrating. The tools just aren't quite there. More often than not, I find myself spending more time wrestling with processes and workflow inefficiencies than I do actually creating.

I've cobbled together a workflow that gets it done well enough for now. I'm mixing various models, custom instructions, and far too much manual intervention. But increasingly, I'm annoyed with how suboptimal it is.

Here's my current workflow, why it frustrates me, and what I think an ideal blogging process might look like.

The current ai-first writing workflow

1. Finding Something Worth Writing About

Usually, this starts with a paper I've read, an idea I've been chewing on, or an intriguing conversation I had recently. I've largely been inspired to lower my bar for this by @simonw's approach to link blogging). That's not to say Simon's posts are low quality, but rather that he's willing to share things that are interesting to him without feeling the need to write a full essay on them.

I'm interpreting this to be more a set of notes for myself that I'm just willing to share.

2. Starting a New Chat in My "Blog" Project

This project has custom instructions tailored specifically for my blogging process.

First, I kick off a new chat session in my "blog" project. Here's what the custom instructions look like:

1# One Example of a "Brennan Blog"
2
3<example>
4  // ...Paste an example blog post here...
5  // ...I'd include more detail, but ChatGPT limits me to 8000 characters...
6</example>
7
8# TASK
9
10I need to write a draft and instructions to send to a content writer. Here’s exactly how we do it:
11
121. I'll begin by uploading a document or sharing a URL I'll be referencing. Initially, do nothing—just respond with "Understood. Continue."
132. I'll then add commentary, images, and notes as I read. Again, stay quiet and respond only with "Understood. Continue." until I'm finished.
143. Once I'm done with notes and observations, I'll say "write." At that point, your task is to turn my notes into a "Brennan Blog" style post.
15
16My posts usually follow this format.
17
18<format>
19  {{Short intro on why this intrigued me, with link}}
20
21  ## {{Observation}}
22
23  > description of img I should include (alt text style)
24
25  - commentary
26  - commentary
27  - commentary
28
29  ---
30
31  ## {{Observation}}
32
33  > description of img I should include (alt text style)
34
35  - commentary
36  - commentary
37  - commentary
38
39  ---
40
41  ...
42
43  ---
44
45  ## Parting Thoughts
46
47  {{Brief wrap-up thoughts}}
48</format>
49
504. When drafting, do your best to match my style from prior posts. Steer clear of formulaic output.
515. Include notes on anything interesting I might've missed or that didn't make it into the final draft.
52
53Got all of that?
54
55(Yes, your initial reply *must* be "Understood. Continue.")

1# One Example of a "Brennan Blog"
2
3<example>
4  // ...Paste an example blog post here...
5  // ...I'd include more detail, but ChatGPT limits me to 8000 characters...
6</example>
7
8# TASK
9
10I need to write a draft and instructions to send to a content writer. Here’s exactly how we do it:
11
121. I'll begin by uploading a document or sharing a URL I'll be referencing. Initially, do nothing—just respond with "Understood. Continue."
132. I'll then add commentary, images, and notes as I read. Again, stay quiet and respond only with "Understood. Continue." until I'm finished.
143. Once I'm done with notes and observations, I'll say "write." At that point, your task is to turn my notes into a "Brennan Blog" style post.
15
16My posts usually follow this format.
17
18<format>
19  {{Short intro on why this intrigued me, with link}}
20
21  ## {{Observation}}
22
23  > description of img I should include (alt text style)
24
25  - commentary
26  - commentary
27  - commentary
28
29  ---
30
31  ## {{Observation}}
32
33  > description of img I should include (alt text style)
34
35  - commentary
36  - commentary
37  - commentary
38
39  ---
40
41  ...
42
43  ---
44
45  ## Parting Thoughts
46
47  {{Brief wrap-up thoughts}}
48</format>
49
504. When drafting, do your best to match my style from prior posts. Steer clear of formulaic output.
515. Include notes on anything interesting I might've missed or that didn't make it into the final draft.
52
53Got all of that?
54
55(Yes, your initial reply *must* be "Understood. Continue.")

Once that's set up, I kick things off with "o3-mini." I outline the core idea behind the post—why it matters to me, what I'm exploring, and how I plan to approach it.

Next, I load all the background content—PDFs, screenshots, links—directly into the chat as I read them. Doing it this way ensures that ChatGPT has as much context as possible.

When I'm done, I invoke "Write Mode." First, I usually use o3-mini-high + search to generate a structured draft:

• I need search as I often reference things that that happened post knowledge cut-off.
• Its job is to combine my notes into something coherent (if not yet polished or engaging—that part comes next).
• It flags notes that didn't make it into the draft.
• It highlights important insights I might've overlooked.

Then I jump over to GPT-4o in Canvas to refine the draft—though honestly, I find GPT-4.5 way better at refinement but, unfortunately, 4.5 isn't available in ChatGPT's Canvas yet.

Canvas itself is an ok editor, but it but often mishandles outside references, mangles image references, and lacks modern knowledge (so will often rewrite things like o3-mini to gpt-4o-mini)

Pretty quickly, I move the whole mess into VS Code to finalize things.

3. VS Code: Image Wrangling & Final Edits

Manual work begins:

• Wrangling images, linking them manually, creating alt texts, and fixing frontmatter data.
• Adding final touches—like embedding tweets (I intentionally keep that out of ChatGPT to survive brutalization).
• Finalizing my main points and conclusions to ensure I'm clear.
• Often I'll copy the whole thing back to canvas, tell chat I've made large edits, and need specific help re-writing a section based on new information.

Finally, I commit to GitHub, and it's Vercel that handles the rest.

Why Is This So frustrating?

• It's shockingly non-collaborative. I'm not actively saying "Yes, and..." with the AI. Instead, ChatGPT tries to one-shot an entire post, usually leveraging knowledge from 2023 or earlier. It's overeager without being helpful. I've had to neuter its responses just to keep things manageable.
• Image handling is painful. ChatGPT doesn't reference or remember submitted images well, so it uses descriptions that I have to manually match back to my own files. This wastes time and energy.
• Way too much manual copy-pasting. Jumping between ChatGPT and VS Code, copying images, and arranging them properly. I'm used to how effortless the Git/GitHub/Vercel pipeline is, and this level of clunkiness just feels inexcusable in comparison.
• Model switching overload. I'm dancing between several GPT models—o3-mini, o3+search, GPT-4o, Canvas, GPT-4.5—and it's an absolute mess rather than a streamlined, thoughtful sequence.
• ChatGPT doesn’t "remember" my style. There's no built-in memory. Every time is like starting from scratch, meaning it never quite nails my tone and approach to content.

What Actually Works Well?

It's not all bad news, though. A few good things stand out:

• Note-taking in chat is honestly awesome. Everything—links, files, text—lives together, accessible later with minimal friction.
• o3-mini does a fantastic job turning raw notes into coherent first drafts. That initial shaping saves mental energy and lets me focus more on the big ideas.
• GPT-4.5 (when I get to use it) is genuinely great at refining drafts. Somehow, it understands what I'm aiming for way better than other models—without steamrolling my opinions in the process.
• Fine-tuning in VS Code with Github copilot is actually really nice especially since next edit suggestions was added. I know that's supposed to be for code, but it's actually pretty good for copy editing too.

Could a Specialized App Be the Answer?

Separately, I’ve built a little app for sharing blogs on 𝕏 and I'm pretty happy with it. It's iterative, naturally has my voice (since it drafts directly from my content), and feels like having my own little editorial team working in the background.

I use Trigger.dev to manage the entire flow. Here's how it works under the hood:

• Kicking things off: The task starts with a new URL being passed in. The agent takes this page URL, scrapes its HTML content, and uses Google Ai's gemini-2.0-flash and @aisdk to turn it into a structured article object.

• Enhancing entities: GPT-4o scans through the structured content, identifying mentioned entities (people, companies, products, etc.). Then, it checks Clearbit’s API to see if these entities have associated Twitter handles, so we can mention them directly in our tweet threads.

• Enriching images: Next, GPT-4o takes a closer look at any images in the post, generating detailed alt-text descriptions and attaching them back to our content object, keeping a full structured representation handy.

• Thread drafting loop: Here's the real magic—an iterative loop between a Writer/Refiner model (GPT-4.5) and an Evaluator model (o3-mini):

  • First up, GPT-4.5 writes out an initial thread draft around a clear format:

    1<thread>
    2  <tweet>Intro hook + image</tweet>
    3  <tweet>... engaging content ...</tweet>
    4  <tweet>Link to original post</tweet>
    5  <tweet>Mentions relevant people/entities from the post</tweet>
    6  <tweet>CTA for engagement</tweet>
    7</thread>
    

    1<thread>
    2  <tweet>Intro hook + image</tweet>
    3  <tweet>... engaging content ...</tweet>
    4  <tweet>Link to original post</tweet>
    5  <tweet>Mentions relevant people/entities from the post</tweet>
    6  <tweet>CTA for engagement</tweet>
    7</thread>
    

  • Then, o3-mini acts as a critical evaluator, scoring the thread's predicted engagement potential based on rules and historical engagement stats baked into the prompt. It returns positive feedback, constructive suggestions, and an overall engagement rating.

  • Depending on its score (I set 75% engagement or higher as the cutoff), the thread either heads directly to me for final approval or loops back to the Writer/Refiner for another improvement round.

• Final review and tweak: Once the AI loop has produced something good enough, I give it a quick final pass—just tiny adjustments usually, confirming mentions, and ensuring it sounds like me. When I'm satisfied, I hit the "post" button, and Trigger.dev kicks off a final task to post directly.

This sparks joy. The final thread is shippable, but lets me edit. And publishing is a single button (a different trigger.dev task that posts to 𝕏).

Could something similar to this workflow make sense for blogging?

Increasingly, I'm sure the answer is yes.

And if we really want blogging to feel like vibe coding, we'll probably need something new—a writing IDE that functions differently from anything we currently have.

1. First, it probably thinks of itself as a note-taking assistant.
2. Then, be a thoughtful writing partner that understands style and approach deeply.
3. And finally, be a seamless publishing and sharing assistant that integrates effortlessly with various platforms.

Parting Thoughts

This is one of those classic founder moments: I deeply want this app to exist, but... I don't really want to be the one to make it.

Maybe someone out there can vibe code it. When you're done, send me a link. I'll happily be user number one.