InsightTube - Turn any YouTube video into an interactive learning experience.

This is a submission for the GitHub Copilot CLI Challenge

What I Built

I built InsightTube, a cross-platform desktop learning app that transforms any YouTube video into a structured study workflow.

The core idea is simple: when we watch long technical videos, we understand some parts, forget others, and rarely revise properly. InsightTube solves that by turning a single video URL into complete learning artifacts instantly.

What InsightTube does

• Fetches YouTube transcript data through a Rust/Tauri backend (including handling scenarios where browser-only transcript approaches often fail)
• Generates AI-powered study materials from the transcript:
  • Summary
  • Study Guide
  • Flashcards
  • Mind Map
• Generates MCQ quizzes with:
  • Adjustable question count
  • Option shuffling
  • Explanations
  • Retry / version history
• Provides a transcript-aware AI chat for each video with:
  • Streaming responses
  • New chat support
  • Chat history per video
• Includes productivity + retention tools:
  • Notes tab (video-specific + general)
  • Todo and reminders support
  • Dashboard with learning stats and activity calendar
• Supports multiple AI providers/models:
  • OpenAI + Gemini
  • Model selection in settings
• Stores user data locally for a fast desktop-first experience

Why I built this

I wanted to convert passive video consumption into active learning.

Most tools stop at “show transcript” or “make summary.” InsightTube goes further: it gives learners a full cycle — understand → test → revise → ask → track — in one place.

Stack

• Desktop: Tauri v2 + Rust
• Frontend: React 19 + TypeScript + Vite
• AI: OpenAI SDK + Google GenAI SDK
• Visualization: markmap for mind maps
• Storage: Tauri store plugin (local persistence)
• UI: Custom dark theme + responsive tab-based study interface

Demo

- GitHub Repository: https://github.com/Mandy324/insightTube

screenshots:

My Experience with GitHub Copilot CLI

This project is where I felt the strongest difference between normal “AI assistance” and true “AI agent workflow.”

With the usual GitHub Copilot extension in VS Code, I still need to interact constantly:

• prompt
• accept/edit
• prompt again
• manually wire pieces together

With Copilot CLI (agent mode), the workflow felt very different:

• I defined the feature goal
• Copilot CLI broke it into subtasks
• It explored the relevant files
• Implemented changes across multiple files
• Ran checks (tsc, build) and iterated on errors
• Returned with a complete, working implementation

What stood out for me

1. Automatic task decomposition
   
   I didn’t have to micromanage implementation order. It created its own step-by-step execution flow.

2. Context-aware multi-file changes
   
   For one feature request, it updated types, services, page logic, and CSS together while keeping consistency.

3. Real development loop, not just snippet generation
   
   It didn’t stop at code suggestion. It validated and fixed issues, which saved a lot of back-and-forth.

4. Huge time savings
   
   I spent more time deciding product behavior and UX, and less time stitching boilerplate + plumbing code manually.

Concrete examples in this project

• SSE Chat + History: It implemented streaming response handling, persistence model, session switching, and UI updates together.
• Dashboard activity calendar fixes: It addressed alignment/timezone bugs after implementation, not just first-pass coding.
• Chat UI redesign from reference image: It refactored structure + styles to match a cleaner no-bubble layout quickly.

Final takeaway

Copilot CLI felt like working with an implementation partner, not just an autocomplete tool.

I just had to define the task clearly; it handled the heavy lifting by planning subtasks and executing them end-to-end. Compared to my normal extension workflow, this removed a lot of constant interaction and saved significant development time.