What I Learned Building AI Tools for Podcast Creators

When I first started recording my podcast, I was completely in love with the creative process. Researching topics, chatting with guests, and editing the audio were incredibly fulfilling. But the moment the recording stopped, my enthusiasm hit a wall. I was staring at a blank text editor, dreading the hours I had to spend writing show notes, crafting episode descriptions, and brainstorming titles.

I tried using a few generic AI writing tools, but the output always felt disconnected. They didn't understand the nuances of podcast formatting, and the titles sounded like clickbait from a decade ago. I was spending more time fixing the AI's mistakes than it would have taken to write it myself.

So, I decided to build something. I wanted to create a suite of tools specifically designed for the podcasting workflow, starting with the things that gave me the most friction.

The Problem

The problem with post-production admin isn't just that it's boring; it's that it's a critical bottleneck for growth. When you skip writing detailed show notes or crafting a compelling title, you aren't just saving an hour. You are actively hurting your discoverability.

Podcast platforms rely heavily on search and recommendations. If your episode description doesn't contain the right keywords, or if your title doesn't create a curiosity gap, listeners will just scroll past. The cost of ignoring this administrative work is a stagnant show that never reaches its potential audience.

But here is the catch: podcasters are usually creators, not copywriters. We want to spend our time making great audio, not writing SEO-optimized summaries. Generic large language models can write text, but they lack the specific context of a podcast episode. They don't know how to extract timestamps naturally, they don't understand how to format a show notes template, and they struggle to generate titles that match a specific brand tone without sounding robotic.

Technical Approach

To solve this, I started building PodCrisp. My initial architecture was a standard monolithic backend, but I quickly ran into issues with latency and costs when processing long transcripts. I needed a way to run AI inference closer to the user without breaking the bank.

This led me to Cloudflare Workers. Moving the heavy lifting to the edge was a game-changer for the user experience, but it came with a learning curve.

One of my biggest early mistakes was over-engineering my prompts. I thought that if I just gave the AI every possible instruction, it would yield perfect results. In reality, it just confused the model. I had to learn how to write concise, rule-based prompts.

For example, when building the title generator, I found that setting strict constraints worked much better than vague requests. Here is the prompt structure I eventually settled on:

// 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 forbidding clickbait and enforcing word counts, the output quality improved dramatically.

Another major hurdle was the show notes generator. Transcripts are messy. They contain filler words, interruptions, and rambling thoughts. My first attempt just dumped the raw transcript into the AI, which resulted in chaotic, unstructured notes.

I realized I needed a structured pipeline. I built a Cloudflare Worker that takes the messy transcript and forces the AI to output a strict markdown structure.

// 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 directly on the edge with Cloudflare's AI models meant I didn't have to manage complex GPU infrastructure. The inference happens quickly, and the structured system prompt ensures the output is always ready to be copy-pasted into a CMS.

Practical Results

Looking back, the transition to edge computing was the most impactful technical decision I made. It kept my infrastructure costs predictable and made the application feel incredibly snappy.

What surprised me the most, however, was how much the "style options" in the title generator mattered. I initially thought users just wanted any good title. But giving them the ability to toggle between "educational", "conversational", or "provocative" tones made the tool actually useful for different types of shows. A true crime podcast needs a very different title than a B2B marketing show.

If I were to start over, I would change my approach to the user interface for transcript uploads. I spent weeks tweaking the AI output formatting, but I neglected the fact that uploading a massive text file in a browser can be clunky. I would invest more time in building a smoother, chunked-upload experience right from day one.

I also learned that building an episode script outline generator requires a different mindset than writing show notes. Outlines need to be forward-looking and structural, whereas notes are backward-looking and summarizing. Treating them as the same prompt task was a mistake that took a few iterations to fix.

Wrapping Up

Building these tools has completely changed how I handle my own podcast admin, and I'm glad to be able to share them with the community. If you are currently struggling with naming your next episode, I put together a free Podcast Title Generator to help you brainstorm. It uses the exact prompt engineering techniques I mentioned above, and you can test it out without needing to create an account.

You can try the free 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.