RepoRadio

💡 Inspiration We live in an era where "Vibe Coding" is taking over, yet understanding a new codebase remains a dry, solitary task. You stare at a README.md, scroll through file trees, and try to grok the architecture. We asked ourselves: What if code review was as passive and entertaining as listening to your favorite podcast?

That’s how RepoRadio was born. We wanted to transform the rigid structure of a GitHub repository into a fluid, conversational radio show. Whether you're commuting, cooking, or just resting your eyes, RepoRadio lets you "listen to the code" through the distinct voices of AI personalities—from "Alex the Hype Man" to "Sam the Cynical Senior Dev."

⚙️ How We Built It We architected RepoRadio as a modular, agentic pipeline:

Secure Ingestion (The "Agent"): We didn't want to just scrape text; we wanted a real dev environment. We used Daytona to spawn ephemeral, isolated sandboxes. The agent clones the repo, parses the file tree, and identifies the tech stack inside a secure container.

The Brain (Agentic RAG): Instead of naively dumping 10,000 lines of code into an LLM context window, we built a "Deep Radio" mode. First, a "Planner" AI looks at the file tree and decides which 3 files are the most critical (e.g., main.rs, schema.prisma). It then dynamically "tools" into those files to read the actual source code.

The Scriptwriter: We chained this context into a robust prompt engine that supports multi-host dynamics. We engineered prompts to enforce distinct personalities (e.g., the Security Researcher vs. the Optimist) and ensure they banter, interrupt, and actually explain the technical concepts found in the previous step.

The Voice Engine (Parallelized Audio): Generating audio line-by-line is too slow for a hackathon demo. We implemented a parallel rendering engine using Python's ThreadPoolExecutor. This splits the script into individual lines and dispatches them to Kokoro (Local ONNX) or ElevenLabs concurrently, rendering a full episode in seconds rather than minutes.

🧠 Challenges We Faced The "Lazy LLM" Problem: Early versions of the AI would ignore our request for 3 hosts, defaulting to a simple 2-person dialogue, or it would stop generating after 4 lines. We solved this by implementing a self-healing script generator that detects if the output is too short and recursively asks the LLM to "continue the conversation" until the episode length requirements are met.

Networking Nightmares: Connecting our local Ollama instance (running on the host metal) to the Daytona containers (running in Docker) was tricky due to network isolation. We overcame this by implementing robust IP detection logic to bridge the container-to-host gap.

Context Window Limits: Large repositories broke our prompts. The implementation of the Agentic Planner (Deep Mode) was the breakthrough here—by letting the AI choose what to read, we maximized the value of our context window tokens.