How I crafted TL;DRs with LLMs and modernized my blog (part 1)

promptgpt-4.1llms.txtcopy-pageweb-performancetldr
tl;dr: I updated my blog with LLM-friendly features and a minimalist design. I created an LLM prompt for short, story-like tl;drs. Every round of prompt tuning kept me curious!
View the series
  1. See how I crafted story-like tl;drs for my posts with LLMs
  2. Learn how I generated my llms.txt summary with LLMs
  3. Grab the "Copy page" button's code, as seen in OpenAI docs
  4. Check how I optimized images for better blog performance
  5. See how impressed I was by GPT-4.1's meta descriptions

A couple of weeks ago, I felt it was time to modernize this blog before digging further into AI automation (pausing the series How I explored Google Sheets to Gmail automation through Zapier before building it in Python).

Since we're living in the AI world, there were two things I absolutely wanted:

  1. The llms.txt and llms-full.txt files at the root of the website, to help LLMs with my content.

  2. A "Copy page" button at the top of each post, to copy its Markdown version just like in OpenAI docs.

Screenshot showing the llms.txt configuration file for managing large language model workflows and a highlighted 'Copy page as Markdown' button, on the automation blog by Tony Aldon about AI automation, LLM integration, and practical no-code and code-based workflow tools.

I also wanted a minimalist UI that looks clean with little to no distraction and that loads fast. I used Lighthouse ↗ to help with performance, and most of the work went into optimizing images:

Screenshot showing Tony Aldon's AI automation blog (tonyaldon.com) achieving a score of 100 in Google Lighthouse performance report, demonstrating excellent site speed and technical optimization for AI workflow tutorials and automation resources.

And finally, I wanted tl;drs at the top of each post. That's where GPT-4.1 (an OpenAI LLM) came in to automate the generation of these tl;drs.

Lucky, I got everything I wanted and more.

I figured I could use the tl;drs for my Atom/RSS feed and llms.txt file. But then Lighthouse reminded me of missing meta descriptions. So, I used GPT-4.1 to generate some from the tl;drs. And whoa, they were so good, I used those meta descriptions for the feed and llms.txt instead.

Get my latest AI automation experiments — free

No spam. Unsubscribe anytime.

Creating the tl;dr prompt

Unlike the posts themselves, which I write fully before asking GPT-4.1 to correct them, for the tl;drs I wanted to do it the other way around: I give the corrected post as input, ask GPT-4.1 to generate a bunch of tl;drs, and then merge and reword them myself until I'm happy with the result.

Here's what I did to create the tl;dr prompt.

First I asked GPT-4.1 to generate this prompt, giving it the following information:

  1. What this blog is about—and what it isn't.

  2. The prompt I use to correct posts.

  3. How I expect the tl;drs to be.

I have a blog where I share what I'm learning about AI automation.
It's a tech blog, and I include code snippets.  I write posts in the
first person and use the past tense to describe what I did.  My posts
are about how I figured out something I wanted to learn.  They're not
tutorials or writing guides, though readers could follow along if they
want, since I share all the details needed to reproduce my process.

Here as the directives I follow to write these posts:

- Keep the grammar and tone intact.
- Make it flow a little bit naturally.
- Keep sentences short or make them shorter.
- Do not touch the code blocks.
- Keep the story-like style with the details.

Can you provide me with a prompt for llms that I could use to produce
tl;drs for these blog posts.  I want them to be:

- Extremely short: 3 short sentences.
- Written in the first person.
- Keeping the tone of the article.
- Maintaining the story-like style.

I got the following prompt:

Summarize the blog post below in a "tl;dr" section.  Use first person
and keep the same tone and storytelling style.  The summary must be
extremely short, no longer than three short sentences.  Do not use
bullet points or lists.  Do not explain or generalize; just capture
what I did in this post as briefly as possible, in my own words.

I tried it with some posts, and it generated this tl;dr for the post How I explored Google Sheets to Gmail automation through Zapier before building it in Python (part 1): 

tl;dr; I built my first Zapier automation to send emails via Gmail
when rows are updated in a Google Sheet, and set it up smoothly using
their template editor.  I tested what happens if required fields are
missing, saw an error both in my inbox and Zapier logs, and used their
troubleshooting tools to diagnose it.  Once I filled all fields
correctly, everything worked perfectly and I was impressed by how easy
the process was.

Good first step, but this is too long for me. So I modified the second directive, requiring each sentence to be under 12 words: 

- The summary must be exactly three short sentences, each under 12 words.

I generated several tl;drs with that prompt to see how GPT-4.1 responded, and at some point it generated the following: 

I built a Zapier automation to email when Google Sheets rows change.
I tested error handling by adding incomplete data and checked the
logs.  Everything worked once I filled all fields correctly—automation
success!

I really liked the ending "—automation success!" It felt warm and personal. In the tl;dr, I hope readers can see I had fun with this project and maybe they'll enjoy reading about it too.

Obviously, I asked for an instruction I could add to the prompt to get this kind of ending. After some trial and error, I settled on the following directive, which worked well: 

- End the last sentence with a playful exclamation showing my
  enjoyment of the process.  Do not invent.  Stay close to my
  words.

My goal isn't to have the model write a perfect tl;dr for me, but instead to help me craft one. So I added: 

- Give me 5 alternatives.

It's not always the case, but here, more options are better. I ended up generating 15 to 20 tl;drs to work with for each post. It costs nothing for an LLM to do this. Literally nothing. And it opens doors for me to find the right words.

At this point, I was playing with the following prompt, generating tl;drs and observing what was working or not: 

Summarize the blog post below in a "tl;dr" section:
- Use first person and keep the same tone and storytelling style.
- The summary must be exactly three short sentences, each under 12 words.
- Do not use bullet points or lists.
- Do not explain or generalize; just capture what I did in this post
  as briefly as possible, in my own words.
- End the last sentence with a playful exclamation showing my
  enjoyment of the process.  Do not invent.  Stay close to my words.
- Give me 5 alternatives.

For instance, it gave me this for How I explored Google Sheets to Gmail automation through Zapier before building it in Python (part 1) post: 

1. I built an automation to send Gmail emails from Google Sheets.  I
   tested errors by adding incomplete rows and used Zapier's
   troubleshooting tools.  This was a fun and smooth first Zap
   experience!

2. I created a Zap that emails Gmail when Google Sheets updates.  I
   explored error handling by submitting incomplete data to Zapier.
   Learning to troubleshoot Zap runs was super satisfying!

3. I assembled my first Zap to connect Sheets and Gmail.  I experimented
   with Zapier's error logs by triggering intentional mistakes.  Making
   automation work this way felt exciting!

4. I set up Zapier to email from Sheets on updates.  I purposely caused
   errors to check Zapier's troubleshooting features.  Building and
   debugging this process was really enjoyable!

5. I linked Google Sheets updates to Gmail sending with Zapier.  I played
   with Zap errors and used their log tools for fixes.  Had a blast
   figuring out my first Zap!

This is when I asked GPT-4.1 to critique the prompt and list the pros and cons. One of the cons caught my attention because I had felt that same tension while generating tl;drs: 

Asking to both "stay close to my words" and "keep storytelling style"
can cause tension for the model: should it paraphrase or quote?

I decided to change "storytelling" to "story-like," using the same wording as my prompt for correcting posts, which already works well. This seemed to make a small difference.

Sometimes, I noticed the last sentence was a bit empty except for the playful aspect. So I added to the directive: 

Do not forget to include a key point.

Other times, sentences contained more than one key point, as in: 

I played with Zap errors and used their log tools for fixes.

I really don't like this. It's too bloated for me.

So, I added:

- Each sentence contains exactly one key point—no more.

At that point I was playing with the following prompt, generating tl;drs and observing what worked and what didn't: 

Summarize the blog post below in a "tl;dr" section:
- Use first person and keep the same tone and story like style.
- Do not use bullet points or lists.
- Do not explain or generalize; just capture what I did in this post
  as briefly as possible, in my own words.
- The summary must be exactly three short sentences, each under 12
  words.
- Each sentence contains exactly one key point—no more.
- End the last sentence with a playful exclamation showing my
  enjoyment of the process.  Do not invent.  Stay close to my words. Do
  not forget to include a key point.
- Give me 5 alternatives.

I was satisfied, but still, something felt wrong. When it generated this tl;dr for the post [ ... ] 

I explored agent behaviors by combining various tools and handoff
configurations.  I puzzled over the "transfer_to_" prefix and sleuthed
through documentation and code.  Getting clarity directly from the
source gratified my inner nerd!

I understood the problem; the vocabulary wasn't mine. I would never use "puzzled," "gratified," or "nerd," and I don't even know how to pronounce "sleuthed."

Finally, I added the following directive, which solved this last problem: 

- Except for technical language, use simple vocabulary.

There was one post, How I realized AI automation is all about what you automate, for which the tl;dr prompt wasn't enough to generate what I wanted. Maybe the post wasn't as clear as the others. Anyway, by just prepending the post with this sentence 

In making this tldr, focus on the really beautiful first example.

the magic happened and GPT-4.1 generated interesting prompts.

TL;DR prompt 

Summarize the blog post below in a "tl;dr" section:
- Use first person and keep the same tone and story-like style.
- Except for technical language, use simple vocabulary.
- Do not use bullet points or lists.
- Do not explain or generalize; just capture what I did in this post
  as briefly as possible, in my own words.
- The summary must be exactly three short sentences, each under 12 words.
- Each sentence contains exactly one key point—no more.
- End the last sentence with a playful exclamation showing my
  enjoyment of the process.  Do not invent.  Stay close to my words. Do
  not forget to include a key point.
- Give me 5 alternatives.

TL;DRs of the first 12 posts

That's all I have for today! Talk soon 👋

Recent posts
latestHow I crafted TL;DRs with LLMs and modernized my blog (part 5)
See how impressed I was by GPT-4.1's meta descriptions
prompt
How I crafted TL;DRs with LLMs and modernized my blog (part 4)
Check how I optimized images for better blog performance
code
How I explored Google Sheets to Gmail automation through Zapier before building it in Python (part 1)
See how I built my first Zapier Gmail alert from Sheets updates
no-code
How I realized AI automation is all about what you automate
Check my favorite CRM AI automation (so far) from Zapier blog
misc
Curious about the tools I use?
Eden
My ChatGPT client for the Emacs text editor.
One.el
My minimal static site generator.
Free course
Build a ChatGPT client in Emacs Lisp.