Misspoke

Mrudula — Sat, 03 Oct 2026 07:22:16 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend.

What I Built

I built MisSpoke, a voice-first AI language practice partner for a friend who wanted to get better at speaking without every conversation feeling like a grammar test.

Most language-learning apps are great at vocabulary, streaks, and exercises, but speaking is a different problem. You can know what a sentence means and still completely freeze when you actually have to say it.

So MisSpoke is built around conversation.

You choose the language you're learning, your level, and the kind of tutor you want to talk to, then just start speaking. The tutor can be calm, casual, motivating, energetic, creative, or a few other personalities depending on what makes practicing less awkward.

It also remembers the conversation, translates things when you get stuck, tracks corrections and recurring mistakes, and keeps the session moving instead of interrupting every five seconds with a red pen.

Demo

🔗 Live: misspoke1.vercel.app

A session is pretty simple:

Choose your native and target languages.
Pick your level and tutor personality.
Start a voice conversation.
Ask for translations or explanations when you get stuck.
MisSpoke keeps track of the conversation and learning signals throughout the session.

You can also fall back to text chat when voice isn't practical.

Code

💻 GitHub: Mrudula-itsjuzme/speak134

The repository name is speak134, but the project itself became MisSpoke somewhere along the way. Naming things is apparently still one of the hardest problems in computer science 😭

How I Built It

MisSpoke is built with:

Next.js 15
React 19
TypeScript
ElevenLabs Conversational AI for real-time voice conversations
OpenRouter for the language-model layer
Supabase for authentication and storage
IndexedDB for local session state and learning memory
Framer Motion + Tailwind CSS for the interface

The app has separate routes for chat, tutor-prompt generation, translation, UI translation, and session summaries.

Voice-first practice

ElevenLabs handles the conversational voice layer, so the learner can actually speak instead of turning language practice back into another typing exercise.

Tutor personalities

The tutor behaviour changes depending on the learner's selected style.

Current personalities include:

cheerful
calm
motivating
intellectual
creative
casual
empathetic
energetic

The personality isn't just cosmetic. It changes how the tutor responds and how the practice session feels.

Languages and translation

MisSpoke supports multiple learning languages, including Spanish, French, Japanese, German, Italian, Korean, Mandarin, Hindi, Tamil, Telugu, Malayalam, and Kannada.

If you get stuck mid-conversation, you can translate a tutor response rather than abandoning the session and opening another app.

Memory

This is one of the parts I cared about most.

The app keeps track of things like:

conversation history
recurring mistakes
vocabulary learned
corrections
confidence
strengths and weaknesses
session summaries
recent practice patterns

Some of this learning state is persisted locally with IndexedDB, while Supabase handles account-level storage.

That means the tutor doesn't have to behave like it has developed amnesia every time you refresh the page.

Why Does Open Innovation Matter?

A language tutor shouldn't have to be permanently tied to one model.

Different models are better at different languages, accents, teaching styles, and kinds of reasoning. Keeping the model layer replaceable means I can experiment with open-weight models through the same application instead of rebuilding the product around one provider.

That matters even more for language learning because the conversations can get surprisingly personal.

People talk about their families, college, work, embarrassing mistakes, plans, opinions, and whatever random thing comes up while they're practicing.

With open models and local inference, there's a path toward keeping far more of that processing on a device the learner controls.

It also means the application can eventually work with:

locally running models
offline inference
fine-tuned language tutors
region-specific models
different models for different target languages
custom correction behaviour

I don't want MisSpoke to become a pretty UI glued permanently to one API.

I want the AI itself to be something I can inspect, swap, adapt, and eventually run locally.

That's the part of open AI that interests me most: the model becomes one component of the product rather than the product becoming dependent on the model provider.

Building It for a Friend

The idea came from a very normal problem: someone can understand English perfectly well and still hesitate when speaking because they're worried about getting something wrong.

And telling someone to “just practice more” is spectacularly unhelpful.

The goal with MisSpoke was to create somewhere you can mess up a sentence, try again, ask what a word means, change the topic completely, and never feel like you're wasting somebody else's time.

I'm handing this version to a friend to try properly rather than evaluating it only from my side of the screen.

The kind of reaction I'm hoping for is something painfully simple:

“Wait, I can just keep talking to it? It doesn't stop me every time I say something wrong?”

If that is how it feels to use, then it is doing what I wanted.

Prize Categories

Best Use of ElevenLabs

MisSpoke uses ElevenLabs Conversational AI as the core voice interface for real-time speaking practice.

Voice isn't an extra feature here. Speaking is the actual product.

What's Next

There are still a bunch of things I want to improve:

better pronunciation scoring
longer-term memory
stronger progress analytics
more natural correction timing
offline/local model support
cloud sync for learning history
mobile polish
testing different open-weight models for different languages

The most interesting problem isn't making the tutor give the technically perfect response.

It's figuring out when it should correct you, when it should explain something, and when it should just let you keep talking.

That feels much closer to how a good human language partner actually works.

Built by Pedamallu Sai Mrudula and Meghana Kotharu.(https://github.com/MeghanaKotharu25)

🔗 Try MisSpoke

💻 View the code

DEV Community: Mrudula