I Spent Hours Writing Show Notes, So I Built an Edge AI Pipeline

I love recording podcasts. The conversation, the flow, the unexpected "aha" moments—it's genuinely a highlight of the creative process. But the moment I hit stop on the recording software, the dread immediately sets in. I was struggling heavily with the post-production admin. Specifically, I’d spend hours staring at a massive, unformatted 45-minute transcript, trying to extract the "good parts" for show notes, craft a catchy title, and write an SEO-friendly description. It felt like a second job, and it was draining the joy out of podcasting for me. So I decided to build something.

The Cognitive Cost of Podcast Metadata

The problem with podcast post-production isn't just that it takes time; it's the severe cognitive context switching. You go from being an engaged, creative host to an analytical SEO copywriter in the span of five minutes. And this matters more than most creators realize. Podcast discovery relies heavily on the metadata. If your title doesn't create a curiosity gap, or your show notes don't clearly outline the value proposition, listeners simply won't click play. Furthermore, podcast platforms use your descriptions and show notes for internal search indexing. The cost of ignoring this metadata is high. Many talented creators burn out and quit, not because they ran out of ideas, but because the operational overhead of packaging those ideas became too heavy to sustain.

Building an Edge-Native AI Pipeline

I needed a way to automate this workflow without sacrificing quality. I didn't want to just slap a generic LLM wrapper on a text box and call it a day. I wanted a system that understood the specific structure and pacing of a podcast episode. I decided to build PodCrisp using Cloudflare Workers, leveraging their edge AI inference. Running AI at the edge means the heavy lifting happens close to the user. This eliminates the cold-start latency you typically get with traditional serverless functions and avoids the need to manage and scale dedicated GPU servers.

Let's look at how I structured the show notes generation pipeline. The goal was to take a raw, messy transcript and turn it into a structured, highly readable format.

// 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' },
    });
  },
};

The magic here is in the system prompt. By explicitly defining the markdown structure, the model knows exactly how to format the output. I'm using Llama 3 8B Instruct via Cloudflare's AI catalog, which strikes a solid balance between reasoning capability and inference speed. I capped max_tokens at 800 to prevent the model from rambling and to keep the edge response times snappy.

For the title generator, the approach is similar but focuses heavily on psychological hooks. Instead of just asking for "a good title," the prompt engineering enforces strict constraints:

// 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.`
  };
}

This ensures the output isn't just a generic summary of the episode, but an actual hook. I also built out an episode script outline generator, an episode description writer, and an SEO keyword suggestion tool using similar prompt structures, ensuring all the metadata works together cohesively.

Practical Results and Iterations

Moving to an edge-native architecture paid off immediately. The UI feels incredibly responsive because the inference happens at the edge, and the structured show notes are surprisingly accurate right out of the box. What surprised me most was how well the model handles timestamp estimation. While it can't know the exact second a topic was discussed without dedicated audio analysis, it does a highly reasonable job estimating the flow based on transcript length and paragraph breaks.

If I were to change anything about the current setup, I’d add more granular control over the output formats. Right now, the show notes structure is hardcoded in the system prompt. I’d love to let power users tweak the system prompt directly or save custom templates for different types of episodes, like separating interview formats from solo monologues.

Try the Free Title Generator

Building these tools for myself ended up helping a lot of other podcasters, too. If you're currently staring at a blank screen trying to come up with a title for your next episode, I've extracted the title generator into a free, standalone tool. You can try it out and generate multiple style options here: Podcast Title Generator.

---

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