Have you ever had an idea that felt so compelling, so fun, but so technically out of reach that you ultimately shelved it?
For me, that idea was the DORA Songsmith, an application that could take a description for a DORA community event, research DORA capabilities, and automatically generate a high-fidelity, three-minute custom lyric video to kick off our discussion sessions.
When I first tackled this project, I approached it with a traditional software engineering mindset. Sitting down, I asked myself: "How would I build this in Python?"
It took months for my mindset to shift, for agentic tooling to mature, and for foundational media models to catch up before I finally achieved an MVP. Today, the DORA Songsmith is a secure, multi-agent pipeline running on Cloud Run.
Here is the story of how I transitioned from developing procedural scripts to orchestrating autonomous agents, and why you should immediately revisit your own "impossible" ideas.
Phase 1: The Monolithic Script Trap
While I brought years of karaoke experience to the table, I had zero background in building audio/visual applications. To kick things off, I relied on a third-party tool to handle creating the custom-lyric MP3 track, allowing me to focus entirely on generating the karaoke-style video.
Back in the summer of 2025, my initial engineering instinct was to construct a linear, standalone Python script. To research how to construct a Python application that generates a video featuring synchronized lyrics and a cohesive visual style from an MP3 file, images, and Gemini, I used gemini.google.com.
After more hours troubleshooting than I care to admit, my cobbled-together solution didn't produce anything I would show the community. I struggled with using models to transcribe and create the videos, and my lack of experience with FFmpeg and MoviePy led to many learning moments.
I hit a wall and decided to go back to searching YouTube for tech parodies. If you haven’t seen it before, check out Imagine DevOps by David Lutz, published in 2011.
Phase 2: The Mindset Shift to Spec-Driven Development (SDD)
The real breakthrough didn't come from writing better Python code. It came from embracing Spec-Driven Development and shifting my role from coder to conductor.
After a few successful projects using Gemini CLI Conductor in December 2025, I knew it was time to revisit the DORA Songsmith dream. When I first sat down with the Gemini CLI to build the MVP, I felt unstoppable. I had access to Lyria and Veo. My goal this round was simple: feed in a DORA report and output a highly engaging, three-minute custom lyric video. Then, I hit the temporal wall: hard time limits on generations.
Quickly, my grand engineering plans collided with the realities of early generative media.
Generating 30 seconds of high-fidelity audio or video is easy. Stitching those clips into a continuous, three-minute experience without inducing a massive technical headache is incredibly difficult.
What got in my way of an MVP this time?
The Audio Key and Tempo Drift
With Lyria, I could easily prompt a beautiful 30-second track. But when I called the API for the next 30 seconds, the model had no native concept of "continuing" the previous clip's audio context. The second clip would start in a different key, at a slightly different tempo, or with entirely different instrumentation.
The "Visual Jar" Problem
Stitching five- to eight-second Veo clips together was even more jarring. While each individual clip was visually impressive in isolation, stringing them together exposed a total lack of visual continuity. Without shared context or persistent scene memory across API calls, art styles shifted dramatically, characters morphed unpredictably, and lighting environments jumped abruptly. Instead of delivering a cohesive, cinematic experience, these "visual jars" produced a disjointed montage that constantly broke the viewer's immersion.
3. Serverless Timeout Pain
Traditional, linear serverless scripts simply couldn't handle the demands of a complex media pipeline. Because they lacked a native mechanism for state persistence or job tracking, a minor network flicker or a standard execution timeout would instantly kill the process mid-render. Without a way to bridge those backend task IDs, a single connectivity hiccup forced a total manual restart, turning hours of progress into a digital ghost.
Again, I'm embarrassed to admit how much time over the holidays I spent trying to code my way out of these limitations with custom Python scripts. I wrote a script using pydub to analyze the BPM of each Lyria clip and apply automated crossfades. While it smoothed out the abrupt silences, it couldn't solve the harmonic mismatch; the sudden key changes still sounded like a radio station switching channels mid-song. I also attempted to feed the final frame of Veo clip 1 back into the API as an image-to-video seed for clip 2. While this anchored initial visual continuity, recursive generation caused rapid quality decay, leaving the video a blurry mess by minute three.
Once again, I was back on YouTube searching for tech parodies to play for the DORA community.
Phase 3: Finally an MVP with the 3 A’s: Amanda, Antigravity, and ADK
Eventually, I realized that trying to force a linear script to solve a multi-model, multi-step creative process was a design flaw. Shifting my mindset from writing code to writing specifications unlocked the true potential of AI building. The DORA Songsmith MVP breakthrough didn't come from writing a more complex Python script; it came from abandoning code-first development in favor of Spec-Driven Development (SDD). I focused on my role as a systems architect rather than a coder, defining what the system would achieve through clear schemas, boundaries, and agent topologies.
Instead of trying to automate everything in a single, fragile script, I shifted to a multi-agent orchestration model. I broke the pipeline down: one agent focused purely on keeping the audio generation cohesive, another handled Veo's reference images to prevent "visual jars," and a stateful orchestrator handled the human-in-the-loop checkpoints.
Instead of treating the application as a massive script, I began designing an Agent Topology using the Agent Development Kit (ADK) and orchestrating the system inside Antigravity.
Rather than writing code, I wrote a System Manifest, a set of clear instructions, boundaries, and schemas and let my agentic team build the software.
| Agent Persona | Core Responsibility | Key ADK Skill / Tooling |
| ----- | ----- | ----- |
| The Lyricist | Researches trusted domains (like dora.dev) to draft technically accurate verses and outputs a timed JSON Lyric Map. | DoraResearchTool + timestamp estimation. |
| The Audio Engineer | Interfaces with Lyria 3 Pro to generate a seamless, 3-minute high-fidelity audio track matching the intended tempo. | Lyria3APIConnector with SynthID watermarking. |
| The Video Producer | Synthesizes an evolving visual backdrop using Veo 3.1 and handles the "Hybrid Layering" of lyrics and overlays. | FFmpegLayeringJob (combining base layer, dynamic subtitles, and charts). |
I will forever remember the feeling when the DORA Songsmith successfully generated a three-minute video based on an event description. My vision was now a reality! Instead of searching for tech parodies, I was uploading DORA Songsmith videos to YouTube.
Phase 4: Secure Serverless Architecture on Google Cloud
To make this a production-grade tool for the DORA community, we wrapped this agentic intelligence in a secure, serverless Zero-Trust Architecture on Google Cloud:
The "Preview & Pivot" Approval Gate: High-compute video rendering is expensive. We built a React web UI on Cloud Run where the user inputs an event description, the Lyricist drafts the lyrics, and the user approves the text before triggering the high-compute audio and video agents.
- The Hybrid Visual Approach: Instead of stitching multiple independent scenes, the Video Producer generates a single, slowly evolving cinematic background using Veo's "Ingredients to Video" consistency feature. It then overlays dynamic Spotify-style lyrics and DORA technical charts exactly when they are mentioned.
- Strict Zero-Trust Networking: All service-to-service communication is handled via Internal VPC and Workload Identity. The FFmpeg rendering container runs in a highly restricted sandbox with zero outbound internet access, ensuring community data never leaks.
- Hardened DevSecOps: Every change pushed to Git triggers a Cloud Build pipeline that automatically scans agent containers for vulnerabilities and signs them using Binary Authorization before deploying.
The Ultimate Lesson: Your "Impossible" Idea is Ready
This journey taught me that building with AI isn't about writing a single perfect prompt or a complex Python file. It is about systems engineering.
Hitting the hard temporal limits of early generative media models is a rite of passage.
My challenge to you: What is the creative, wild, or "impossible" tool you shelved last year?
Don't wait years to try again. In the current landscape, weeks are the new years. Fire up your IDE, write your system specs, and start building.