How to Build an AI Audio Content Repurposer

An ai audio content repurposing system converts one recording into blog posts, social media content, and summaries automatically. I build these for founders and experts who talk better than they write. Record a 20-minute voice memo about your expertise, and the system produces a full week of content from it.

The bottleneck is never the content. It is the transformation from spoken to written format. AI eliminates that bottleneck.

What You Need Before Starting

• Audio recordings (podcasts, interviews, voice memos, webinars)
• Python 3.8+ with whisper and anthropic
• Content templates for your output formats
• A publishing workflow

Step 1: Transcribe the Source Audio

import whisper

model = whisper.load_model("medium")

def transcribe(audio_path):
    result = model.transcribe(audio_path)
    return result["text"]

Step 2: Generate Multiple Content Formats

import anthropic

client = anthropic.Anthropic()

def repurpose_audio(transcript, source_title):
    formats = {}

    # Blog post
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1500,
        messages=[{
            "role": "user",
            "content": f"""Convert this transcript into a 600-800 word blog post.
Title: {source_title}
Write in first person. Conversational tone. Short paragraphs.
Include subheadings. Remove verbal fillers and repetition.

Transcript:
{transcript[:6000]}"""
        }]
    )
    formats["blog_post"] = response.content[0].text

    # Social media posts
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=600,
        messages=[{
            "role": "user",
            "content": f"""Extract 5 social media posts from this transcript.
Each post: 1-3 sentences. Standalone insight. No hashtags.
Make each one shareable on its own.

Transcript:
{transcript[:4000]}"""
        }]
    )
    formats["social_posts"] = response.content[0].text

    # Email newsletter
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=500,
        messages=[{
            "role": "user",
            "content": f"""Write a newsletter email based on this transcript.
Subject line + body. Under 300 words. One key takeaway. Casual tone.

Transcript:
{transcript[:4000]}"""
        }]
    )
    formats["newsletter"] = response.content[0].text

    # Key quotes
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=300,
        messages=[{
            "role": "user",
            "content": f"Extract the 5 most quotable lines from this transcript. Clean them up for readability.\n\n{transcript[:4000]}"
        }]
    )
    formats["quotes"] = response.content[0].text

    return formats

Step 3: Build the Full Pipeline

import os
import json

def process_audio_to_content(audio_path, title, output_folder):
    os.makedirs(output_folder, exist_ok=True)

    transcript = transcribe(audio_path)
    with open(os.path.join(output_folder, "transcript.txt"), "w") as f:
        f.write(transcript)

    content = repurpose_audio(transcript, title)

    for format_name, text in content.items():
        with open(os.path.join(output_folder, f"{format_name}.md"), "w") as f:
            f.write(text)

    manifest = {
        "source": audio_path,
        "title": title,
        "transcript_words": len(transcript.split()),
        "formats_generated": list(content.keys()),
        "processed_at": datetime.now().isoformat()
    }

    with open(os.path.join(output_folder, "manifest.json"), "w") as f:
        json.dump(manifest, f, indent=2)

    return manifest

Step 4: Generate Thread Format

def generate_thread(transcript, platform="linkedin"):
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=800,
        messages=[{
            "role": "user",
            "content": f"""Convert this transcript into a {platform} thread/carousel.
5-7 slides/posts. Each one makes a single point.
First slide: hook. Last slide: call to action.
Short sentences. One idea per slide.

Transcript:
{transcript[:4000]}"""
        }]
    )
    return response.content[0].text

Step 5: Track Content Production

def log_repurpose(source_audio, formats_created, word_counts):
    conn = sqlite3.connect("content.db")
    conn.execute("""
        INSERT INTO repurpose_log (source, formats, total_words, created_at)
        VALUES (?, ?, ?, datetime('now'))
    """, (source_audio, json.dumps(formats_created), sum(word_counts.values())))
    conn.commit()

What to Build Next

Add content calendar integration. After generating all formats, automatically schedule them across your platforms. Monday gets the blog post, Tuesday the newsletter, Wednesday through Friday the social posts. One recording fills an entire week.

Related Reading

• AI for Content Creation at Scale - content repurposing as the ultimate scale strategy
• The One Person Company Is Here - one person producing multi-format content
• The Compounding Advantage Nobody Talks About - content repurposing compounds over time