Inspiration

What it does

Audigo 🎧

Turn your lecture slides, notes and recordings into podcasts, audiobooks and TikTok-style clips, so you can study by ear, on the go, with your class.

Inspiration

Students spend hours on buses, at the gym and walking between lectures, while their study material sits in PDFs and slide decks they can only read at a desk. Lecture slides are walls of text that don't talk back, and re-reading them is the least effective way to revise. But almost everyone already listens to podcasts. We asked: what if your own course material sounded like your favourite show?

The name says it: audio + go. We wanted the friendliest possible version of that, so it looks like a student's desk: notebook paper, highlighters, sticky notes and masking tape, in a loud, chunky neo-brutalist style. Nothing about it should feel like another grey learning portal.

Learning also isn't solo. Classmates already share notes in group chats, and teachers already set reading. So Audigo is built around classes and study groups from the start: shared episodes, listening homework and a leaderboard to fight over.

And short-form video is where students actually spend their attention. If a "Subway Surfers under a podcast" clip can hold someone's attention for 60 seconds, it can teach them Michaelis-Menten kinetics. So every episode can become a reel.

What it does

Upload anything, get an episode. Drop in a mix of files (PDF, Word, PowerPoint, text/markdown notes, whiteboard photos, lecture audio) and choose:

  • Podcast: two or three AI hosts talk it through. Prof. Ada explains with analogies, Sam asks the questions you were too shy to ask, Jordan busts misconceptions, and Remy turns facts into exam hooks.
  • Audiobook: one calm narrator reads spoken-word chapters written for the ear.
  • Length: Bus ride (5 min), Gym session (15) or Long walk (30).

You watch the agents work through a to-do list with a live stopwatch and per-stage timings, and every episode remembers how long it took to make.

Every host is its own AI agent. In the Host Studio you tune each host's personality, tone (warm, playful, dry, formal), voice pitch, enthusiasm and talking speed, or invent a new host. Enthusiasm changes both what they say and how they sound.

Record a live lecture. Hit record and get a live transcript. Star the exam-worthy lines, then turn the whole lecture into a podcast for the trip home. There's also a demo lecture mode that works on any device.

Listen anywhere, even offline.

  • Player: chapters, a synced transcript you can tap to jump to, speed control, a sleep timer, bookmarks, and lock-screen controls.
  • Keeps playing: a "now playing" mini-player keeps going while you move around the app.
  • Offline: save episodes for no-signal commutes.
  • Habits: a study streak and a weekly listening goal keep you coming back.

Test yourself. Every episode has a quiz in two styles:

  • πŸƒ Flashcards: think, tap to reveal, mark "got it" or "missed it".
  • πŸ”˜ Multiple choice: five Claude-written questions with four options each. The distractors are built from real misconceptions, and every answer gets an explanation.

Learn with your classmates.

  • Classmates feed: see what people in your subject are listening to, say "πŸ™Œ this helped me", and leave timestamped class notes.
  • Ask the class: post a topic you're stuck on. Others tap "me too", and someone claims it and makes the episode.
  • Remix: remake a classmate's episode with your own choice of hosts, without re-uploading anything.

Classes and study groups. Join with a 6-character code.

  • Teachers set listening homework with due dates and points, and moderate a class audiobook shelf where students suggest episodes for approval.
  • Study groups are peer-run: anyone can set a challenge.
  • Homework completes automatically once you've actually heard 80% of the episode (scrubbing to the end doesn't count).
  • Leaderboard: quiz scores feed a podium-style leaderboard: on-time tasks score full points, late ones half, and right answers add bonus points.

Make it a reel. Pick any moment up to 60 seconds and Audigo renders a vertical 1080Γ—1920 MP4 for TikTok, Reels or Shorts:

  • Captions: TikTok-style word-pop subtitles synced to the audio, coloured by whichever host is speaking.
  • Layout: a speaker chip, a live waveform and the episode title on top of muted Minecraft parkour, satisfying slime or Subway Surfers gameplay.
  • Preview and share: preview it live, then download it or send it straight to an app with your phone's share sheet.

Built for phones, great on desktop. On a phone it's a single column with a bottom tab bar. On a big screen it becomes a dashboard with a sidebar, stat tiles, homework, leaderboards, and a right-hand rail with now playing, your week and what's due.

How we built it

Frontend: Next.js 15 (App Router) with React 19 and Tailwind CSS v4, built as an installable PWA. A service worker caches the app shell, and saved episodes live in Cache Storage with an IndexedDB index. The neo-brutalist design system (Unbounded, Space Grotesk, Permanent Marker, hard ink shadows, a ruled-paper background) was explored on the Superdesign canvas first.

AI pipeline (Claude): a chain of agents, each with its own job, all on Claude Opus 5.5:

  1. Extraction agent: reads every source together. PDFs and images go to Claude natively, and DOCX, PPTX and audio are converted to text first. It returns a typed study pack (concepts with analogies, definitions, a teaching outline, exam facts, quiz) using structured outputs validated by a Zod schema.
  2. Producer agent: plans the episode as segments sized to the target length, each with a specific teaching brief and a turn budget, ending in a quiz.
  3. Host agents: each host is a separate Claude call with its own persona prompt. They take turns, react to what was just said, know where they are in the segment, and sign off properly at the end.
  4. Narrator agent: writes spoken-word audiobook chapters.
  5. Quiz agent: writes the multiple-choice questions, cached per episode. We shuffle the options ourselves so the right answer doesn't always land in the same slot.

Voices (ElevenLabs):

  • Speech: multilingual v2 text-to-speech, with a different voice for each pitch setting. Each host's enthusiasm and speed are mapped onto ElevenLabs' voice settings (stability, style, speed).
  • Mixing: lines are voiced four at a time with automatic retries, then joined into one MP3 with chapter markers.
  • Transcription: Scribe transcribes uploaded lecture audio, and we use single-use tokens for live transcription.

Clips (ffmpeg):

  • Shared timing code: a single timeline module turns the script into 2–4-word caption chunks. Both the browser preview and the server render use it, so the preview matches the final video.
  • Subtitles: the server writes an .ass subtitle file (per-word colour, outlines, pop-in animation) and burns it in with libass.
  • Gameplay: ffmpeg jumps straight to 1:00 in the 20–40-minute videos, reads only the seconds it needs, and drops their audio entirely.
  • Contrast: if a host's caption colour would vanish into the background, it switches to a contrasting one automatically.

Data: SQLite (better-sqlite3) holds sources, study packs, episodes, comments, requests, groups, tasks, listening progress, shelves and quizzes. Jobs stream progress to the browser over Server-Sent Events.

Process: we split work across parallel Claude Code sessions with a written ownership plan. Each machine owned a separate set of files, the shared types were frozen, and the API formats were agreed up front, so branches merged without conflicts.

Challenges we ran into

Episodes that ran long. Our first real 5-minute podcast came out at 11 minutes, because the hosts wrote 60–100 words per turn. The fix was a per-turn word budget, a producer that sizes segments to a turn budget, and quiz turns budgeted per question. Episodes now land at about 6 minutes for a 5-minute target.

Endings that trailed off. We told every segment's last turn to "hand over to the next segment", including the final one, so episodes ended with "let's carry these ideas into the next part…". Now hosts know when they're on the episode's last line and sign off properly.

Getting reliable JSON out of the model. The newest Claude models don't support forcing a specific tool call, so we switched every agent to structured outputs with Zod schemas, plus checks for truncated or refused answers.

Subtitle timing without word timestamps. We only know when each line starts, so word timings are estimated within each line from word length, with pauses after punctuation. It's convincing, but it's an estimate.

Low-res landscape gameplay in a vertical frame. The background videos are 640Γ—360. We tried split screen and full screen, and found a sponsor banner burned into the slime video at exactly 1:00, so that one starts at 1:10.

Windows-specific surprises.

  • Subtitle paths: ffmpeg's subtitle filter breaks on Windows drive-letter colons, so we run each render from its own folder with relative paths.
  • The β–Ά character renders as a coloured emoji on Windows, so the play buttons use drawn SVG icons.
  • Stale caches: mixing a production build and the dev server in one folder produced confusing errors until we cleared the build cache.

Config gotchas. Next.js gives .env.local priority over .env, so a leftover placeholder file kept the app in demo mode even after real keys were added.

Running out of design credits. Our design tool ran out of generation credits mid-session, so we wrote the designs ourselves and imported them onto the canvas instead.

Accomplishments that we're proud of

  • Real files, real show: three mixed files (lecture notes, a slide outline, an audio clip) became a coherent two-host podcast, with chapters and a quiz, in under two minutes (112 seconds, including reading and transcribing every file). The hosts used the lecturer's analogies, flagged the "exam favourite" from the notes, and reacted to each other like a real show.
  • Short versions are fast: a 5-minute audiobook generates in under 30 seconds, and a 15-second reel renders in about 20.
  • Hosts are true agents: every host is configurable, and changing enthusiasm audibly changes the delivery.
  • One codebase for two jobs: the same timeline code drives the live preview and the final MP4, so what you preview is what you post.
  • Collaboration you can actually use: classes, study groups, homework that completes by actually listening, moderated shelves, remixes and leaderboards.
  • A distinctive look: something students would genuinely want to open on the bus.

What we learned

  • Write for the ear: audio learning lives or dies on the script. "No markdown, short sentences, signpost, define every term" made a bigger difference than any voice setting.
  • Give agents budgets: models drift long unless you hand them explicit word and turn budgets and tell them exactly where they are in the episode.
  • Validate in code: structured outputs plus code-side checks beat "please return JSON" every time.
  • Share the timing logic: sharing one timing module between the preview and the server render removed a whole class of "it looked different in the browser" bugs.
  • Prompt and enforce: small rules (8-word titles, no em dashes) are best enforced in both the prompt and the code.
  • Agree contracts early: frozen shared types, written API formats and file ownership let us build in parallel quickly without merge pain.

What's next for Audigo

  • Exact word timings: use ElevenLabs' timestamped text-to-speech so subtitles land precisely on each word.
  • Live lecture transcription through ElevenLabs: stream the Record page to Scribe in real time (the token is already wired up), with browser captions as the fallback.
  • Real accounts: add sign-in, so teacher roles and leaderboards can't be claimed just by typing a name.
  • "Explain this bit": tap any transcript line for a two-sentence clarification, plus flashcard export to Anki.
  • Sharper reels: HD gameplay backgrounds, more clip templates, and captions placed in the classic TikTok centre position.
  • Proven offline playback: verify saved-episode playback end to end on real phones, and polish installing the app.
  • Deployment: run the AI pipeline and the ffmpeg renders as background workers, so they can run on serverless hosting.
  • Teacher insights: see who's falling behind on listening homework, and nudge them before the deadline.

Your lectures, in your ears, on your commute. Study by ear, learn together. Audigo.

Built With

Share this project:

Updates

Submission history