I Built Clasez: An AI Study Copilot That Changes How Students Use Lecture Recordings with the GitHub Copilot SDK

This is a submission for the GitHub Copilot CLI Challenge

What I Built

I built Clasez, an AI powered CLI tool that transforms lecture transcripts into structured summaries, contextual key concepts, important takeaways, and searchable timestamped answers using the GitHub Copilot SDK.

But... why?

As a student balancing internships, community work, and university lectures, I kept running into the same situation. I would miss a class because I had to be somewhere else. Or I would sit down before finals ready to review, open a two hour recording, and realize I had no idea where the important explanation was. I would drag the timeline back and forth trying to find the exact moment the professor explained one concept that I knew would show up on the exam.

And yes, tools like this already exist. There are transcript summarizers that can help you break down recordings. But most of them either limit how much you can upload or hide the useful features behind subscriptions that many students simply cannot justify paying for every month (That is exactly the gap the GitHub Student Developer Pack helps close)

Then I realized something. I already had access to Copilot Pro through the GitHub Student Developer Pack. I had access to powerful models. There was also the GitHub Copilot SDK, so instead of looking for a tool, I could build one.

Clasez was born there. It is not just a summary generator. It is a study copilot that helps you focus on what actually matters in a lecture.

The Tool

If your university allows you to download lecture transcripts, even better if they include timestamps, that is all you need. At least in my case, recordings usually come with a .txt or .srt file.

With Clasez, you provide the transcript and it transforms that raw text into structured, usable study material. Here is what that actually looks like in practice.

1. Structured Lecture Summary

   Clasez generates a concise but meaningful summary of the entire lecture. This is not just a short paragraph to skim but the kind of overview you would read the night before an exam.

2. Contextual Key Concepts

   Instead of pulling generic definitions, Clasez extracts the key concepts as they were explained in class.

3. Important Takeaways and Action Items

   This is where it becomes practical. Clasez identifies moments where the professor hints at exam relevance, suggests exercises, assigns homework, or emphasizes something as important.

4. Q&A with Timestamps

   And last but not least, the interactive Q and A mode. You can ask specific questions about the lecture, and if timestamps are available, Clasez returns the exact minute references. Instead of rewatching everything, you go straight to what matters. And during finals week, that difference is huge.

Demo

First of all, here's the GitHub repository

For the demo, I wanted something that anyone in the tech industry could recognize. So I used a transcript from CS50, specifically a Data Structures lecture. It is one of the most popular programming courses in the world, and it felt like the perfect example.

After installing the CLI, you simply run:

clasez

You are greeted with a clean terminal interface and a simple interactive menu. One thing I really wanted was for this to feel like a real product, not just a script that prints text (I took the idea from the GitHub Copilot Banner).

As you can see, you need to be authenticated with your GitHub Copilot subscription to access Pro models, or use a token.

Before loading a transcript, you can head into settings and choose which model you want to use. Through GitHub Copilot, you can switch between models from Anthropic and Open AI. As a student, being able to select a powerful model through your GitHub Copilot subscription to analyze your own lectures is honestly mind blowing. Let's go with the popular Opus 4.6 for this.

Loading the Transcript

For this example, I downloaded the .srt transcript of the CS50 lecture so timestamps would be included. Once loaded, Clasez analyzes the file and displays useful metadata.

Seeing twenty seven thousand words and over one hundred minutes of lecture time immediately shows the scale of what you are about to process.

Generating Insights

From the main menu, you can choose what you want to generate. You can run everything at once or select specific features depending on what you need.

For the demo, I generated the full analysis. The summary is streamed in real time inside the terminal.

Next, the key concepts are generated. For this lecture, it identified things like trees, tries, arrays, hash tables, and memory management concepts. But what makes it useful is that the explanations are grounded in how they were discussed during class.

Then come the important takeaways. This is where Clasez surfaces exam hints, practical exercises, and emphasized topics. For example, it highlighted as important topic: "Linked lists allow dynamic memory allocation but require extra space for pointers; search is O(n), but prepending can be O(1)" and as Action Item: "Transition to Python programming language coming next week, which will abstract away manual memory management"

Those are exactly the kinds of details that tend to show up later in problem sets or exams.

Q&A Mode

Finally, I entered Q&A mode.

I asked Clasez, "At what time did Professor Malan explain tries?". And instead of a vague answer, Clasez returned specific timestamps for the introduction, insertion examples, constant time lookups, and even the discussion about space trade offs.

That means you can go directly to minute 01:54:03 instead of scrubbing randomly through a two hour recording.

And if you need to revisit previous questions, the conversation history is accessible from the menu.

My Experience with GitHub Copilot CLI

GitHub Copilot CLI was key for Clasez development.

The moment that pushed me to build this was watching James Montemagno use the GitHub Copilot SDK to build a podcast generator.

At the beginning, I did not fully understand how the GitHub Copilot SDK worked under the hood. My background is stronger in Python, and some of the examples I explored were structured differently than what I was used to.

So I did something simple. I used Copilot CLI to understand Copilot SDK.

I started by using the web_fetch tool to explore the SDK documentation, understand how requests were structured, and see how streaming responses were handled.

Then I switched to plan mode.

Plan mode was probably the most important feature during the early stage. I used it with a premium model to define my MVP clearly. What features should be included in version one. How transcript parsing should be handled. How to structure the CLI menus. What should be separated into layers so the project would not become messy later.

Instead of jumping straight into code, I had a phased plan.

After that, I went into the popular vibecoding mode. I used slash commands inside the CLI to generate boilerplate, refactor functions, and iterate quickly. I asked it to scaffold the transcript parser. I refined prompt templates for summary generation. I improved how timestamps were extracted and formatted.

Of course, it did not work perfectly at first.

The first time I tested the full flow, something broke. Then came debugging.

This is where Copilot really felt like a pair programmer. I pasted error traces, asked it to analyze edge cases, and walked through the logic step by step. It helped me identify issues in how transcripts were being parsed and how prompts were structured for longer inputs.

I also used it to fetch and summarize documentation, especially because the Copilot SDK is still relatively new. Instead of guessing how something behaved, I would ask Copilot to clarify expected behavior or suggest a cleaner approach.

Instead of feeling limited by time or complexity, I felt like I could experiment more. Try new features. Refactor confidently. Explore ideas I would normally postpone.

Clasez started as an idea to save time during finals. But building it changed the way I see what students can actually create. Because once students realize they can build tools like this, the Student Developer Pack stops being just a benefit and starts becoming a launchpad.

This is something that I will start mentioning when I talk about the GitHub Student Developer Pack in student communities.

GitHub Repository: jamesrhurtado/clasez-cli