How I Engineered Edge AI Prompts for Better Podcast Titles

When I first launched my indie developer podcast, I thought the hard part was recording the episodes. I was wrong. The real nightmare began the moment I hit "stop" on the recording. I would sit there staring at a blank text editor, trying to come up with a title that didn't sound like a dry college lecture, and then I had to write the show notes. It took me nearly as long to write the metadata as it did to record the actual episode.

I was spending hours context-switching from "creative host" to "SEO marketer," and it was draining my energy. So I decided to build something.

The Hidden Cost of Bad Podcast Metadata

You can record the most insightful, technically deep episode of your life, but if the title is boring, nobody is going to click play. Podcast platforms don't listen to your audio; their algorithms and human scrollers read your title and description.

The problem isn't just about getting clicks, though. It's about the cognitive load. When you're deep in the creative zone, forcing your brain to suddenly think about SEO keywords, curiosity gaps, and structured timestamps breaks your flow. The cost of ignoring this friction is burnout. Many great podcasts die simply because the creator gets tired of the administrative overhead. I needed a way to automate the boring parts without losing the human touch.

Architecting an Edge AI Pipeline

To solve this, I started building PodCrisp. I wanted the tool to be fast, reliable, and capable of handling natural language processing without the massive latency of traditional cloud functions. I chose to build the backend on Cloudflare Workers, utilizing their AI inference capabilities at the edge.

Running AI inference at the edge means the model execution happens physically closer to the user. This eliminates cold starts and keeps latency incredibly low, which is crucial when you're iterating on prompts and need immediate feedback. To set this up, you define your AI binding in your wrangler.toml configuration, mapping it directly to the Workers AI catalog. This keeps your routing logic clean and your API keys secure.

Prompt Engineering for Titles

The biggest mistake developers make with AI title generators is sending a lazy prompt like, "Give me a title for a podcast about X." The AI will give you generic, uninspired results. You have to treat the system prompt like a strict API contract.

Here is the core logic I use for the title generator:

// 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
);

Notice the constraints in the system role. By explicitly defining the word count, forbidding overpromising clickbait, and injecting a dynamic tone variable, the output becomes highly usable. Early on, I didn't include the "no clickbait" rule, and the AI kept giving me titles like "You Won't Believe What Happened Next." Adding that single constraint fixed 90% of the garbage outputs.

Automating Show Notes with Structured Outputs

Once the title is sorted, the next bottleneck is show notes. Listeners love skimming, and search engines love structured text. I built a pipeline that takes a raw transcript and converts it into a standardized format.

Here is how the Cloudflare Worker handles the show notes generation:

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

By using Llama 3 at the edge, I can process large transcripts quickly. The trick here is the system prompt structure. By forcing the AI to output specific Markdown headers (## Episode Summary, ## Key Takeaways, etc.), I guarantee that the frontend can reliably parse and render the notes without needing complex regex or post-processing logic.

Practical Results and Iterations

Moving the AI inference to the edge was a game-changer for the user experience. The latency is practically non-existent, making the tool feel like a native app rather than a web wrapper.

What surprised me most was how much the tone variable in the title prompt changed the utility of the tool. Passing "technical" versus "inspirational" yielded completely different, yet highly accurate, title options. It allowed me to reuse the same core logic for different types of episodes without rewriting the prompt.

If I were to change one thing about the initial architecture, it would be how I handle transcript chunking. Early on, I passed entire transcripts to the show notes generator. For episodes longer than 45 minutes, this occasionally hit token limits or caused the AI to lose focus on the middle of the text. I've since implemented a sliding window approach for longer transcripts to maintain context fidelity.

Wrapping Up

Building these tools completely changed my podcasting workflow. I went from dreading the post-production metadata to having it done in seconds. If you're a fellow developer or creator struggling with the same post-production bottleneck, I packaged the title generator into a free tool. You can try it out and see how it handles your specific topics.

You can test the free Podcast Title Generator here: https://podcrisp.com/free-tools/title-generator

---

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