How I Stopped Dreading Podcast Show Notes by Building an AI Tool

I used to spend hours after recording a podcast episode just staring at a blank screen. The recording was the fun part, but writing the show notes, summaries, and titles felt like a massive chore. I would listen to my own voice on 2x speed, trying to pull out key timestamps and resources, only to end up with vague, unhelpful notes. I realized I was spending 80% of my post-production time on admin work instead of actually improving the content or talking to guests. So I decided to build something.

The Hidden Cost of Podcast Post-Production

The real cost of ignoring podcast post-production isn't just time; it's consistency and discoverability. When you rush through show notes, you miss out on SEO opportunities. When you write weak titles, your click-through rate drops. Many indie podcasters I talked to were either skipping show notes entirely or spending their weekends manually transcribing and formatting.

The friction of turning raw audio into structured, searchable content is a massive bottleneck. If the admin work feels heavier than the creative work, you eventually burn out and stop publishing. I needed a way to process transcripts quickly without managing heavy GPU servers or paying for expensive enterprise API tiers.

Moving AI Inference to the Edge

This led me to Cloudflare Workers and their AI inference at the edge. Instead of routing requests to a centralized API, edge inference lets the AI model run close to the user. For podcasters uploading transcripts, this means lower latency and no cold starts from spinning up dedicated inference servers.

When building the architecture for PodCrisp, I had to choose between traditional centralized AI APIs and edge inference. Centralized APIs are great for massive context windows, but for standard podcast transcripts, edge inference offers a better balance. The trade-off is that you have to be more mindful of payload sizes and token limits, but the benefit is that you don't have to manage server spin-up times.

Let's look at how I structured the show notes generation pipeline. The trick with LLMs is strict prompt engineering to ensure the output is always usable.

// Show notes generation pipeline (Cloudflare Workers + AI)
export default {
  async fetch(request, env) {
    const { transcript } = await request.json();

    // Call AI model for structured show notes
    const response = await env.AI.run('@cf/meta/llama-3-8b-instruct', {
      messages: [
        {
          role: 'system',
          content: `Convert podcast transcripts to show notes:
## Episode Summary (2-3 sentences)
## Key Takeaways (5-7 bullet points)
## Timestamps (estimate from content flow)
## Resources Mentioned`
        },
        { role: 'user', content: transcript }
      ],
      max_tokens: 800,
    });

    return new Response(JSON.stringify(response), {
      headers: { 'Content-Type': 'application/json' },
    });
  },
};

In this pipeline, the env.AI.run method calls the Llama 3 model directly from the Worker. The system prompt is the most critical part here. If you just say "summarize this," you get a wall of text. By enforcing a strict markdown schema in the system prompt, the output is immediately ready to be pasted into a CMS. I set max_tokens to 800 to keep the notes concise but detailed enough to be useful.

For the title generator, the challenge was avoiding the generic "AI voice." AI loves to use words like "Unlock," "Discover," and "Dive deep." To combat this, I added specific rules to the prompt.

// Prompt engineering for podcast title generation
function buildTitlePrompt(topic, tone, count) {
  return {
    system: `You are an expert podcast producer. Generate compelling titles.
Rules:
- 5-10 words each
- Use curiosity gaps, numbers, or strong hooks
- Match the tone: ${tone}
- No clickbait that overpromises
- Format as numbered list`,
    user: `Episode topic: ${topic}

Generate ${count} title options that make someone want to click play.`
  };
}

By explicitly banning clickbait and enforcing a curiosity gap, the AI generates titles that sound like a human producer wrote them, rather than a marketing bot.

Practical Results and Lessons Learned

Moving to edge inference completely changed my workflow. What used to take an hour of active listening now takes about 30 seconds of processing and 5 minutes of light editing. The structured show notes are actually better than my manual ones because the AI catches minor resource mentions I would usually forget to write down.

One surprise was how much the strict system prompts mattered. Initially, the AI would hallucinate exact timestamps. Adding a specific instruction to "estimate from content flow" rather than "extract exact timestamps" fixed the hallucinations, since the raw text doesn't contain actual audio timing data.

What surprised me most about the broader toolset was the SEO keyword suggestions feature. I initially built it just to help with the episode pages on my own site, but the edge AI is surprisingly good at extracting long-tail keywords from the transcript context. It doesn't just pull out the main topic; it finds the specific questions asked during the interview.

If I were to change one thing, I would probably implement a streaming response for the show notes generator. Right now, the user waits for the full JSON response. Streaming the markdown tokens as they are generated would make the perceived latency feel much lower, even if the total processing time is the same.

Try the Title Generator

If you are struggling with the post-production grind, I have packaged the title generator into a free tool so you can test the prompt engineering yourself. You can try the Podcast Title Generator at podcrisp.com/free-tools/title-generator to see how different tones affect the output and get some inspiration for your next episode.

---

Full disclosure: I'm the developer of PodCrisp. I built this because I needed it myself.