I Built an English Practice Coach for My Friend

Ritik Verma — Sun, 04 Oct 2026 13:52:53 +0000

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

What I Built

English Practice Assistant is a personal English coach that remembers how you communicate.

I built it for a friend of mine, Vikas. They read documentation and code easily and follow meetings without trouble, but freezes when they have to speak: explaining a bug, giving a standup update, or disagreeing politely in a code review. They think in their first language and translate word for word, so the same mistakes keep coming back:

"Yesterday I complete the login page and fix two bugs."
"I will discuss about the payment flow. Please do the needful and revert back."

They had tried chatbots and grammar apps. Chatbots would correct one sentence and then forget it. Grammar apps teach rules they mostly know already. Neither notices that past tense has gone wrong twelve times this month, and neither lets them practise the situations they actually face at work.

So I built a practice partner that remembers:

Normal conversation: chat about anything and get gentle, short feedback.
Workplace English: some common scenarios, including daily standup, explaining a bug, code review, asking for help, manager update, client meeting, technical presentation, disagreeing professionally and project status.
Targeted practice: drills for grammar, natural English, vocabulary, professional tone, and "Recurring mistakes", a mode built from the learner's own error history.

After every message the coach replies naturally, and a small collapsible feedback box shows the natural version, a one-line reason and the pattern name. Once a mistake type shows up twice, the app shows "Recurring pattern detected", and from then on that weakness goes into the coach's prompts so later sessions focus on it. The Progress page shows recurring-mistake bars, skill indicators and recent sessions. Everything there comes from real data: with no data it says so, and with little data it says that too.

Demo

🎥 Video demo: [VIDEO LINK]

🌐 Live app: https://english-coaching-flutonp.onrender.com/
(choose Google AI Studio in the provider dropdown and paste your own free key; it's kept in your browser for only 30 minutes)

A quick walkthrough:

Normal conversation: "Yesterday I go to a new cafe…" → feedback, then Recurring pattern detected on the second past-tense slip.
Workplace English → Daily standup: "Please do the needful and revert back" → a professional rewrite.
Targeted practice → Recurring mistakes: the coach builds an exercise on past tense without being told, because it remembered.
Progress page: past tense at the top of the recurring-mistakes chart.

Code

ritikverma-chaibrew / week1

English Practice Assistant

A personal English coach that remembers how you communicate.

An AI-powered practice partner who understand English well but struggle to express ideas naturally at work. Gemma does the language intelligence; the app adds persistent memory of the learner's recurring mistakes and uses it to adapt every future session.

Why I Built This

A friend of mine reads documentation and code easily and follows meetings, but freezes when they have to explain a bug or give a standup update. They translate directly from their first language, and the same mistakes keep coming back.

The Problem

Generic chatbots correct a sentence and forget it. Grammar apps teach rules the learner already roughly knows. Neither notices that "past tense" has been wrong twelve times this month, and neither practices the learner's real situations: standups, code reviews, client meetings.

The Idea

Chatbot → AI coach → AI coach with memory →…

View on GitHub

How I Built It

Open-weight model: Gemma. All of the language work is done by Google's open-weight Gemma models. Each learner message triggers two Gemma calls in parallel:

a conversational reply in the coach persona, for the current mode or scenario, and
a structured evaluation returned as JSON (mistakes with category, original, correction, short explanation and a 0–100 score), validated with Pydantic v2. If Gemma returns invalid JSON, the app retries once with a repair instruction, and if that also fails it shows "feedback unavailable" instead of crashing.

Two ways to run Gemma, chosen from a dropdown in the app:

Local inference with LM Studio: download a Gemma instruct model (e.g. gemma-3-4b), start LM Studio's server, pick the model and connect. Nothing leaves the laptop.
Google AI Studio: bring your own API key for hosted Gemma (e.g. gemma-4-31b-it). The key stays in the browser for 30 minutes and is then deleted automatically.

Both work because the provider talks to any OpenAI-compatible /v1/chat/completions endpoint that serves Gemma. vLLM or Ollama would also work. Gemma's chat template rejects a separate system role and requires strictly alternating turns, so the app folds the instructions into the first user turn and strips Gemma's <thought> blocks from replies.

Memory makes it a coach rather than a chatbot. Every detected mistake is stored in MongoDB Atlas (mistakes collection), and a learning_profiles document keeps recurring-mistake counts, smoothed skill indicators and strengths. Any mistake type that appears 2 or more times counts as recurring. The learner's top recurring weaknesses, together with only the last few messages (never the whole history and never database IDs), go into each prompt. That keeps prompts small enough for a 4B model on a laptop.

flowchart TD
    Browser -->|fetch| FastAPI
    FastAPI --> ConversationService
    ConversationService -->|prompt + recurring weaknesses| Gemma[Gemma: LM Studio or AI Studio]
    ConversationService --> MemoryService
    MemoryService --> MongoDB[(MongoDB Atlas)]
    MongoDB -->|learning profile| ConversationService

Stack: Python 3.12, FastAPI, Pydantic v2, async PyMongo, httpx, Jinja2 and plain HTML/CSS/JS (no frontend framework). It has a Dockerfile and a Render blueprint. A deterministic mock provider and an in-memory database fake let all 42 tests run without a key or a database.

Why Does Open Innovation Matter?

My friend practises with sentences they're embarrassed by, and some of them are about real work: real bugs, real clients, real managers. An open-weight model means those sentences can stay on their own laptop. With LM Studio running Gemma locally, there is no API account, no per-message cost and no third party reading their practice history.

Building this made me realize that the interesting part of an AI application isn't always the model itself.
Gemma provides the intelligence, but the memory, feedback loop, and product logic are what turn it into a useful learning tool.
I'm still experimenting with it, and I'd love to see where local AI models can take this project next.

Open also made the following possible:

It costs nothing to practise every day. Language learning only works with repetition, and a metered closed API turns every practice sentence into a bill. A local Gemma model costs nothing per message.
The model can be swapped without rewriting the app. The AI sits behind a small AIProvider interface. I moved from hosted Gemma to local LM Studio by changing a dropdown, not the learning system. A smaller Gemma model suits a slow laptop and a larger one suits better feedback, and the memory and product logic stay the same.
I could see and adapt to the model's behaviour. Because Gemma's chat template is public, I could handle its exact quirks (no system role, alternating turns, thought blocks) instead of guessing at a black box.
It can be fine-tuned later. Because the weights are open, a future version could fine-tune Gemma on the common mistakes of speakers from one language background. That isn't possible with a closed model.

A closed API could store the same mistakes. What open gives my friend is privacy, zero running cost and control over the AI layer.

Prize Categories

Best Use of Gemma: Gemma powers every conversational reply and every structured evaluation, either locally through LM Studio or hosted through Google AI Studio.
Best Use of MongoDB Atlas: Atlas stores the learner's memory (mistakes, recurring-pattern counts, skill indicators and sessions) that drives each personalised prompt.
Best Use of Render: project included render.yamland deployed on render . ## What I Learned

The biggest thing I learned from building this is that the model is only one part of an AI application.

The interesting work is in everything around it memory, prompts, feedback, user experience, and deciding what information the AI should remember.

Even a relatively small open-weight model can become a useful application when you build the right system around it.

And honestly, that's the part I enjoyed the most. 🚀

Open-source AI is getting interesting

Ritik Verma — Sun, 04 Oct 2026 13:41:55 +0000

I've been experimenting with open-source AI models, and honestly, it's pretty exciting to see how much we can run locally now.

Models like Gemma, Llama, Mistral, and Qwen can be downloaded and run on your own machine using tools like LM Studio or Ollama.

No API key.

No per-request cost.

And your data can stay on your machine.

Of course, running models locally has its own challenges — hardware, memory, speed, and model size all matter.

But the idea that you can run a capable AI model on your own laptop is pretty amazing.

I'm going to explore this space more and share what I learn along the way. 🚀

Have you tried running an open-source model locally? What model are you using?

DEV Community: Ritik Verma