Why I Stopped Writing Podcast Show Notes and Built an Edge AI Tool

I was struggling with the post-recording slump. After a great 45-minute podcast episode, I'd stare at a blank screen for an hour trying to write show notes, come up with a catchy title, and format everything for SEO. The creative energy was completely gone. I realized I was spending more time on metadata and administrative tasks than actual content creation. So I decided to build something.

The podcasting industry has shifted significantly over the last few years. It's no longer just about hitting record and uploading an audio file; it's about discoverability, retention, and structured content. Listeners have infinite choices. If your title doesn't hook them, or your show notes don't provide quick, scannable value, they simply move on to the next show. The shift from audio-only to SEO-driven podcasting means the text surrounding the audio is just as important as the audio itself.

But the cost of ignoring this metadata isn't just lost downloads—it's severe creator burnout. Podcasters are burning out because the SEO and formatting tasks are drowning out the actual creative work. We need a way to bridge the gap between raw audio and polished, discoverable content without losing hours of our lives to manual typing.

When I started looking at how to solve this, I noticed a broader trend in AI tooling: everything was being routed through heavy, centralized cloud providers. This adds latency, increases costs, and complicates the architecture. For a podcast tool that needs to process transcripts and generate titles quickly, latency kills the user experience.

I decided to build PodCrisp on Cloudflare Workers, leveraging AI inference at the edge. This means the heavy lifting of natural language processing happens closer to the user, drastically reducing the time it takes to generate show notes, outlines, and titles.

Let's look at how I approached the prompt engineering for the title generator. It's not just about asking an LLM to "give me a title." You have to constrain it to avoid generic clickbait while maintaining curiosity.

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

// Example: generate 5 titles for a bootstrapping episode
const prompt = buildTitlePrompt(
  "How to start a podcast with zero budget",
  "inspirational",
  5
);

By explicitly defining the rules in the system prompt—like limiting word count and banning overpromising clickbait—the model outputs much more usable options.

For the show notes generator, the pipeline is a bit more complex. We take the raw transcript and pass it to an edge-deployed model to structure it into summaries, takeaways, and timestamps.

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

Running this on Cloudflare Workers means we aren't managing server infrastructure. The env.AI.run call handles the inference seamlessly at the edge, keeping the architecture lightweight. The trade-off, of course, is that edge models have smaller context windows than massive centralized models, so we have to chunk longer transcripts carefully before processing. While centralized models might offer slightly broader general knowledge, edge models are incredibly fast and highly capable for structured, domain-specific tasks like formatting show notes.

What worked really well was the edge inference approach for perceived performance. Generating a full set of show notes from a standard transcript feels almost instantaneous. What surprised me was how much the structured system prompts improved the quality of the episode script outlines. When you force the model to think in specific sections, the output is actually usable by creators.

If I were to change anything, I'd probably add more granular control over the tone for the SEO keyword suggestions, as podcast niches vary wildly in how formal or casual they need to be.

If you're a podcaster looking to streamline your workflow, or just a developer curious about edge AI prompt engineering, I'd love for you to try the free Podcast Title Generator I built. It's a great way to see the prompt engineering in action without needing to sign up for anything.

Check it out at https://podcrisp.com/free-tools/title-generator.

---

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