AI Agents Still Can’t Use Your Stack. I Built a Fix.

Harikrishnan — Tue, 17 Feb 2026 18:15:19 +0000

We’ve made documentation readable for machines.

We’ve built agents that can run workflows, call tools, and execute multi-step logic.

And still… they don’t really work with the stacks we actually use.

If you’ve ever gone looking for an existing Agent Skill for something even slightly niche, you know the feeling. You search. You scroll. Nothing fits.

Your stack exists.

Your docs exist.

Your agent exists.

But they don’t speak the same language.

That’s the friction.

The Missing Layer

We now have llms.txt. It gives documentation a structure that models can read without guessing.

We also have Agent Skills. These let agents do real work by loading instructions, workflows, and domain-specific logic when needed.

But they solve different problems.

llms.txt helps agents understand systems
Agent Skills help agents operate them

Right now, moving from one to the other is still manual work.

Even if your documentation is perfectly structured, someone still has to sit down and turn it into a skill.

That’s the part that doesn’t scale.

So I Built: txtskills

txtskills takes documentation and turns it into usable agent skills.

You drop in an llms.txt URL (or even just a docs base URL), and it:

Pulls the documentation
Interprets the structure
Converts it into an installable Agent Skill

From there, the generated skill can be installed into any compatible coding agent with a single command.

Claude Code, Amp, Antigravity, VS Code, or any environment that supports the open Agent Skills format.

No rewriting workflows by hand.

No packaging instructions manually.

Just:

Docs → Understanding → Execution

Why This Matters

Agent Skills are how teams are starting to capture real working knowledge.

Not just prompts, but:

internal processes
repeatable workflows
operational logic

Once written, these can be reused across agents.

The problem is getting them built in the first place still takes time.

txtskills handles that conversion step.

If documentation exists, turning it into something an agent can actually use shouldn’t be a separate project.

Try It

Live: https://txtskills.hari.works/

GitHub: https://github.com/hk-vk/txtskills

Upvote on Peerlist: https://peerlist.io/harikrishnanvk/project/txtskills--convert-llmstxt-to-agent-skills

GitTalks: Turn Any GitHub Repo Into a Podcast.

Harikrishnan — Thu, 12 Feb 2026 14:19:08 +0000

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!

DEV Community: Harikrishnan

AI Agents Still Can’t Use Your Stack. I Built a Fix.

The Missing Layer

So I Built: txtskills

Why This Matters

Try It

[Boost]

GitTalks: Turn Any GitHub Repo Into a Podcast.

Harikrishnan ・ Feb 12

GitTalks: Turn Any GitHub Repo Into a Podcast.

What I Built

Screenshots

The Vision

How It Works

What Makes This Interesting

Demo

Try It

Testing Instructions for Judges

Features

My Experience with GitHub Copilot CLI

Setup

Plan Mode

Agent Skills

Implementation

Polish

What I Learned