How I Built an AI Podcast Assistant on Cloudflare Workers

When I first started my tech podcast, I thought the hard part was getting guests and recording the audio. I was wrong. The real time-sink hit me the moment the recording stopped. I’d sit down with a 45-minute audio file and a raw transcript, staring at a blinking cursor, trying to write a catchy title, a structured summary, and SEO-friendly show notes.

I’d spend two hours just trying to find the "hook" of the episode. I’d write a title, hate it, rewrite it, and eventually settle for something bland like "Episode 12: Talking about Cloud Architecture." It was exhausting. I wanted to create content, but I was drowning in post-production admin.

I looked at existing AI tools, but they felt like generic wrappers. I had to manually copy-paste transcripts, tweak massive prompts, and format the output myself. It didn't feel like a workflow; it felt like a second job.

So I decided to build something.

The Problem

The core problem isn't just that writing is difficult. The problem is context switching. When you finish a deep, technical conversation with a guest, your brain is in "creator" mode. Forcing it to immediately switch to "marketer" mode to write click-worthy titles and structured notes is jarring and inefficient.

For independent podcasters, this friction is a silent killer. If the post-production process is too painful, you either stop podcasting or you publish episodes with poor titles and zero show notes. The cost of ignoring this is low discoverability. A great episode with a bad title is an episode nobody clicks on.

I needed a tool that understood the specific nuances of podcasting. It needed to generate titles that create curiosity without resorting to cheap clickbait, and show notes that actually help listeners navigate the audio. Generic AI tools could do this if you spent an hour prompt-engineering them, but I wanted a dedicated, frictionless experience.

Technical Approach

I named the project PodCrisp. My main technical goal was to keep it fast and keep the infrastructure costs predictable. I didn't want to manage a fleet of GPU servers or deal with the cold-start latency of traditional serverless functions.

I chose to build the backend entirely on Cloudflare Workers. Cloudflare’s edge network is massive, and their Workers AI platform allows you to run inference directly at the edge. This means the AI models are physically closer to the user, drastically reducing latency.

One of the first challenges was prompt engineering for the title generator. LLMs tend to be overly enthusiastic. If you ask for a "compelling title," it gives you things like "Unlock the Secrets of the Universe!" I had to build strict constraints into the system prompt to keep the titles grounded and relevant to the podcast niche.

Here is the function I use to build the prompt 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 explicit negative constraints: "No clickbait that overpromises." This single line dramatically improved the quality of the output.

For the heavier lifting, like converting raw transcripts into structured show notes, I built a dedicated Cloudflare Worker pipeline. Instead of just asking the AI to "summarize this," I force it to output specific markdown sections.

Here is a simplified version of the Worker handling 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 defining the exact markdown headers in the system prompt, the AI knows exactly how to structure the output. I also cap the max_tokens to prevent the model from rambling, which keeps the API costs down and the output concise.

Practical Results

Building PodCrisp has been a great learning experience in edge computing and applied NLP. What worked exceptionally well was the deployment model. Because everything runs on Cloudflare Workers, the tools feel instantaneous. There is no loading spinner; the AI inference happens so fast at the edge that it feels like a local application.

What surprised me was how much the model's behavior changed based on the persona in the system prompt. When I told it it was an "expert podcast producer," the titles were significantly better than when I just said "act as a copywriter." The domain-specific context matters immensely.

If I were to change one thing, it would be how I handle massive transcripts. Initially, I tried to pass 10,000-word transcripts directly into the context window. While the models can handle it, the quality of the summary degrades in the middle. I’ve since started breaking transcripts into chunks, generating notes for each chunk, and then synthesizing them. It adds a bit of latency, but the accuracy of the timestamps and key takeaways is much higher.

Try It Out

If you are a podcaster struggling with the post-production grind, or just a developer curious about edge AI, I’d love for you to try the tools I’ve built. You can start with the free Podcast Title Generator to see how the prompt engineering works in practice.

You can try it here: Podcast Title Generator

It’s completely free to use, and I hope it saves you from staring at a blinking cursor after your next recording session.

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