This is a submission for the GitHub Copilot CLI Challenge
What I Built
GitTalks turns GitHub repositories into multi-episode podcast playlists. It uses AI to analyze any repository and generate a series of conversational audio episodes that explain the codebase's architecture and implementation. Each repository becomes a structured podcast with multiple episodes covering different aspects of the code.
Live Demo: https://gittalks.vercel.app/ | GitHub: https://github.com/hk-vk/gittalks
Listen to Sample Podcasts:
Screenshots
The Vision
Developers are drowning in documentation. Complex codebases demand hours of reading, scrolling through files, piecing together mental models. What if you could learn from code while commuting? Or exercising? Or doing literally anything else?
GitTalks lets you paste a repository URL and get back a podcast. Not a robot reading README files, but actual conversations between two developers walking through the codebase like they're explaining it to a colleague.
How It Works
Repository Analysis
The system uses Google's Gemini 2.0 Flash model (via Vercel AI SDK) to analyze repository structure. It parses file trees, identifies dependencies, and maps out how components interact. The AI decides what's worth explaining:
- Overall architecture
- Core components and how they connect
- Notable design patterns
- Framework integrations
- Implementation techniques worth calling out
Multi-Episode Playlists
Here's the main hook: GitTalks doesn't generate one long audio file. It creates a playlist of episodes, each focused on a specific part of the codebase. Small repos might get 2-3 episodes. Large frameworks could get 8+. Each episode covers a distinct topic, so you can skip around or focus on what matters to you. Think podcast series, not audiobook.
Text-to-Speech
Audio generation uses DeepInfra's Kokoro TTS (OpenAI-compatible API). Natural voices, emotional range, fast synthesis. I built custom MP3 chunking with proper Xing headers so long episodes don't break in players.
Duo Conversation Mode
The audio isn't a monotone narration. It's a conversation between two people. An expert host explains the architecture while a curious co-host asks clarifying questions. Stolen directly from NotebookLM's "Deep Dive" style, because it works. This duo format makes complex technical decisions feel like normal conversations between developers, not dry documentation.
Pipeline
Generation happens in stages:
- Fetch repository data from GitHub (smart file prioritization)
- LLM analyzes structure and generates episode plan
- LLM writes dialogue scripts for each episode
- TTS synthesizes audio (multiple episodes in parallel, rate-limited)
- Upload to S3, cache the results
Caching
If someone already generated a podcast for a repo, you get instant access. No re-processing. GitHub star counts cache for 24 hours client-side. Edge caching handles static assets.
What Makes This Interesting
The technical challenge wasn't calling AI APIs. It was orchestrating them reliably. LLMs and TTS have rate limits, transient failures, and unpredictable latencies. The pipeline handles all this with retry logic, exponential backoff, and parallel processing where safe.
The UX challenge was making "wait 2-3 minutes while we generate your podcast" feel acceptable. Real-time job status updates help. So does caching.
The product challenge was episodes. One 45-minute audio file for a large repo is unusable. Breaking it into topical episodes makes the content navigable.
Also: this runs entirely on free tiers + $10 worth of API credits. . GitHub API is generous. Gemini has a free tier. Only Kokoro TTS costs money, and even then it's cheap at scale.
Demo
Live Application: https://gittalks.vercel.app/
GitHub Repository: https://github.com/hk-vk/gittalks
Video Walkthrough: https://www.youtube.com/watch?v=YgoDKz1e09c
Try It
- Go to the homepage. You'll see popular repos (Next.js, React, VS Code, Tailwind) with live star counts.
- Paste any GitHub URL or click a featured repo.
- Wait 2-3 minutes while it:
- Fetches the repository
- Analyzes the structure
- Generates episode scripts
- Synthesizes audio
- Hit play. You get a web audio player with standard controls.
- Episodes are saved. Shareable URLs work.
Testing Instructions for Judges
Authentication:
To generate new podcasts, sign in with your GitHub account (no special permissions required). The app only needs basic profile access.
Quick testing without signing in:
You can listen to pre-generated podcasts immediately without authentication:
To test full generation flow:
- Sign in with GitHub
- Enter any public repository URL
- Wait 4-10 minutes for generation
No special credentials needed - any GitHub account works!
Features
- Browse and search public GitHub repositories
- Automatic multi-episode playlist generation
- Two-host conversational narration
- Audio player with progress tracking
- Recent playlists feed
- Authentication for saved playlists
- Mobile-friendly
The demo video shows the UI, job tracking, episode player, and generated audio quality.
My Experience with GitHub Copilot CLI
This was my first time using Copilot CLI. I wasn't sure what to expect, but it ended up doing most of the heavy lifting.
Setup
I installed Copilot CLI and started a session by typing copilot in my terminal. Simple.
Plan Mode
I'd read about Plan Mode in the docs. It's a feature where you describe what you want to build and Copilot generates a full implementation plan. I opened it (Shift+Tab, or /plan) and described the idea:
"GitTalks: a podcast app where users enter a GitHub repository URL and the system generates an audio playlist of episodes that narrate everything about the repo. Use Next.js for both backend and frontend."
A couple minutes later, I had a detailed plan. Architecture decisions, file structure, API routes, database schema, deployment approach. All laid out step-by-step. I approved it. Here's the full plan: GitTalks Implementation Plan
Agent Skills
Then I discovered Agent Skills. These are specialized plugins that extend what Copilot can do. I installed a few, including the frontend-design skill from Anthropic.
One prompt: "use frontend skill to generate the frontend of the app."
It generated about 80% of the production frontend you see live. Component structure, responsive layouts, gradient UI, interactive elements. One shot.
Implementation
After that, I worked through the plan:
- Backend API routes (GitHub integration, job management)
- Authentication (Better Auth)
- Rate limiting
- AI content generation (LLM orchestration)
- TTS integration
The only manual work was configuring external API keys (DeepInfra, Google Gemini). Copilot can't log into third-party dashboards, obviously.
Polish
Once the core was done, I used Copilot chat for refinements. Better error handling, loading states, UI polish. It helped with all of it.
What I Learned
Plan Mode is legitimately useful for project architecture. I didn't have to guess at folder structure or debate database choices. It proposed something reasonable, I tweaked what needed tweaking, done.
Agent Skills are amazing. The frontend generation was pretty good. No back-and-forth, no iterations. Just working code.
Staying in the terminal helped. No context switching to web UIs or separate tools. I stayed in my editor.
Would I use it again? Yes. For complex projects, the planning phase alone saves hours.
Thanks for reading through this. Hope you enjoyed exploring GitTalks!
Top comments (2)
This is a really clever approach to making codebases accessible. The duo conversation format is what sells it — monotone narration kills engagement, but back-and-forth dialogue keeps you listening.
The episode-based structure is smart too. One giant audio dump for a large repo would be useless. Breaking it into topical episodes mirrors how good podcast series work.
Curious about the content freshness angle — do you regenerate episodes when repos get major updates? That could be interesting for tracking architectural evolution over time.
I've been working on something adjacent at giv1.com — a combined newsletter + podcast platform focused on letting creators own their content and RSS feeds. The podcast space is really opening up with these kinds of tools that lower the barrier to creating audio content. Would love to see GitTalks integrate with standard podcast RSS so people could subscribe in their regular podcast apps.
Thanks for the review. I’m planning to implement a regeneration flow based on Git diffs in subsequent iterations.