Git Commit History to Dual-Host Podcast: A Hands-On ElevenLabs Tutorial

The Changelog Nobody Reads Is a Story Nobody Has Heard

Every software project has a changelog, but almost no one actually reads it line by line. They're typically a pile of dry commit summaries: fix: resolve login bug, feat: add export feature... The information is there, but it's cold, lifeless, and completely devoid of narrative.

The original author proposed a genuinely imaginative idea: since a changelog is fundamentally a story about "what changed in this project," why not turn it into a listenable, two-person podcast conversation? Using a coding Agent, ElevenLabs' Text to Dialogue API, and ffmpeg, the author completed the entire pipeline — from Git commit history to finished audio — in under an hour.

What looks like a small toy project actually demonstrates a combination pattern that's becoming increasingly common in modern AI engineering: Agent processes structured data → generative API handles media conversion → traditional tools handle final assembly.

How the Pipeline Works

The author breaks the entire process into three clean stages, each with a distinct responsibility that flows naturally into the next.

Step 1: A Coding Agent Reads Git History and Writes the Dialogue Script

The starting point isn't asking a human to summarize the updates — it's letting a coding Agent read the project's real Git commit history directly. This is crucial: it means the podcast content is grounded in actual code changes, not artificially crafted or overly polished PR copy.

The Agent's job isn't just to extract commits — more importantly, it must rewrite those technical changes as a two-person dialogue script. In other words, it needs to transform facts like "added export feature" into natural back-and-forth conversation between a host and a guest. This step tests the LLM's ability to understand technical content and convert dry information into engaging narrative.

Step 2: ElevenLabs Text to Dialogue API Generates the Two-Voice Audio

With the dialogue script in hand, the author calls ElevenLabs' Text to Dialogue API to render the written conversation into actual "host + guest" audio.

Unlike traditional single-channel TTS (text-to-speech), Text to Dialogue is purpose-built for multi-speaker conversation scenarios. It assigns different voices to different characters and creates a genuine sense of conversation through natural variations in tone, pacing, and pauses. This is precisely what makes the "changelog podcast" sound like two people actually talking — not a robot reading a script.

ElevenLabs is one of the leading commercial platforms in voice synthesis, known for its high-fidelity voice cloning and multilingual support. Its Text to Dialogue API is specifically designed for multi-character conversation scenarios. The key difference from a standard TTS endpoint is that a single request can specify different voices for different speakers — the model automatically switches vocal tones between dialogue turns and handles natural variations in speed, emotion, and pause rhythm appropriate to the conversational context. Developers don't need to call TTS separately for each line and manually stitch clips together; an entire "question-and-answer" segment can be generated as a single cohesive unit. This dramatically simplifies multi-speaker audio production and explains why the API is frequently used in podcast automation, AI companion products, audiobooks, and similar applications — it compresses what would otherwise require multiple rounds of audio editing into a single API call.

Step 3: ffmpeg Stitches Everything into a Complete Podcast Episode

The final step is handed off to the classic audio/video processing tool ffmpeg, which stitches the individual audio segments into one complete podcast episode. ffmpeg plays the role of "glue" here — it generates no creative content, but ensures the final output is a properly formatted, ready-to-publish audio file.

ffmpeg is an open-source, cross-platform audio/video processing framework that has been around since 2000 and remains one of the most widely used low-level media tools in the industry. It's a command-line program that supports virtually all mainstream audio/video formats through a rich set of parameters — encoding, decoding, conversion, trimming, concatenation, and filtering. In AI automation workflows, ffmpeg often plays a "last mile" role: AI-generated audio clips are typically inconsistent in format and duration, and ffmpeg is responsible for normalizing encoding formats, setting sample rates, concatenating them into a single file, and outputting podcast-compatible formats like MP3 or AAC. It consumes no API costs, runs extremely fast locally, and is the most stable component in generative AI content production pipelines.

Why This Case Study Deserves Attention

The Classic "Agent + Generative API + Traditional Tools" Architecture

The most instructive aspect of this project is how it demonstrates a pragmatic AI application architecture. When many people think about AI applications, they want the LLM to handle everything "end-to-end." But in practice, the more efficient and controllable approach is almost always division of labor:

• Semantic understanding and script generation: handled by a coding Agent;
• Voice media rendering: handled by the specialized ElevenLabs voice synthesis API;
• File processing and assembly: handled by the battle-tested ffmpeg.

Every stage uses the right tool for the job, reducing costs while improving reliability. This "combination" mindset is a valuable reference for any developer building AI automation workflows.

The "coding Agent" referred to here is a large model-driven program with tool-calling capabilities: it doesn't just generate text — it can actively execute operations like reading files, running command-line tools, and calling APIs, then decide on next steps based on the results. Unlike a single-request call to an LLM API, Agent mode allows the model to perform multi-step reasoning and tool orchestration throughout a task — for example, calling git log to retrieve commit history, analyzing the output, and then writing the dialogue script. Common Agent frameworks include LangChain, AutoGen, and the native Function Calling / Tool Use mechanisms provided by various model vendors. The reason this architecture has spread so rapidly in AI engineering is precisely because it combines the LLM's semantic understanding capabilities with the ability to read and write real system data — enabling a complete "understand → decide → execute" loop.

Making Developer Documentation Come Alive

From a product perspective, this case study addresses a genuine pain point: developer content reach. Changelogs, release notes, and technical blog posts are often written and never read. Converting them into podcast format opens up an entirely new, lower-friction consumption channel for the same information — users can catch up on project updates while commuting or working out, just by listening.

For open source project maintainers and DevRel (developer relations) teams, this offers a new idea for automated content distribution: every time a version ships, automatically generate an accompanying podcast episode.

A Lightweight Practice You Can Replicate in One Hour

The author emphasizes that this was "a complete one-hour build," meaning the barrier to entry is low. It's not a project requiring a large team or long-term investment — it's a prototype an individual developer can get running in an afternoon. This also reflects the maturity of today's generative AI toolchain: audio content production that once required professional voice actors and editing teams can now be automated with just a few API calls.

Further Reflections: Giving Voice to Sleeping Structured Data

This "Git commit history to podcast" project fundamentally answers a more universal question: how do you transform structured data sleeping inside your systems into content people actually want to consume?

Git history is just one example. The same pattern transfers to: database change logs, monitoring alert summaries, quarterly business data, meeting notes... Any data that has information but is presented in a boring format can theoretically go through an "Agent narrativization → generative media rendering → tool assembly" pipeline and emerge as a podcast, video, or other more shareable form.

That said, it's worth staying clear-eyed: AI-generated dialogue scripts can introduce factual inaccuracies or over-dramatize, especially when trying to "storify" technical changes. For release notes where accuracy is critical, it's still worth keeping a human review step in the loop.

Overall, this is a small but sharp, highly instructive engineering case study. It doesn't show off with complex architecture — yet it precisely demonstrates a new paradigm for content production in the generative AI era: let machines read the data, and let the data speak for itself.