DEV Community: Ritik Verma

An English Coach

Ritik Verma — Sun, 18 Oct 2026 17:01:58 +0000

An English Coach: Your Personal English Tutor

This is a submission for the Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle.

What I Built

I built an AI-powered English coaching app that helps people improve their English communication skills through personalized practice and feedback.

Many people understand English but struggle to speak confidently, express their thoughts naturally, or communicate effectively in professional environments. Traditional English courses can be expensive, and learners often lack someone to practice with regularly.

My goal is to make English coaching more accessible by giving learners a personal AI tutor they can practice with anytime.

The app is designed to help users improve their grammar, vocabulary, sentence formation, and overall communication skills through interactive learning and personalized feedback.

Who Would Pay for It?

Students preparing for interviews, placements, and competitive opportunities.
Software developers who want to communicate confidently in meetings and technical discussions.
Job seekers preparing for interviews.
Professionals who want to improve their workplace communication.
English learners who want to speak more naturally and confidently.

The side-hustle opportunity is to offer affordable, AI-powered English coaching through a freemium model, with premium features for learners who need more personalized practice.

Demo

Live Demo: Try the AI English Coach

Code

GitHub Repository: Explore the source code

How I Built It

I built the application around the idea that learning English should be interactive, personalized, and accessible rather than limited to watching lessons or memorizing grammar rules.

The application uses AI to act as a personal English coach, helping users practice and improve their communication skills.

The core experience focuses on:

Personalized English practice.
Feedback on grammar and sentence construction.
Suggestions for more natural ways to express ideas.
Practical communication scenarios.
Learning through practice rather than lengthy grammar lessons.

For the AI layer, I used Gemma from Google.

My goal is to make the application useful for learners who need consistent practice but cannot afford a personal English tutor.

Why Does Open Innovation Matter?

English communication skills can create opportunities in education, employment, and professional growth. However, access to quality coaching is not equally available to everyone.

Open innovation makes it possible to experiment with open-weight AI models, customize the coaching experience, and build affordable learning tools without depending entirely on expensive proprietary AI APIs.

It also creates opportunities to adapt the application for different learning needs, languages, and cultural contexts.

For example, an English learner in a smaller Indian city should be able to access a personalized English coach without paying the price of traditional one-to-one coaching.

Open models can also provide greater control over deployment, model selection, privacy, and operating costs, depending on the model license and infrastructure.

Prize Categories

Best Use of Gemma
Best Use of Render

Touch Grass Tales: go for a walk, come back with a picture book

Ritik Verma — Fri, 09 Oct 2026 21:21:42 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

Touch Grass Tales turns a short walk into an illustrated children's story.

You step outside, photograph 5 to 10 random things (a park bench, a pigeon, a weird sign, a lamp post), and an open-weight model, Gemma, turns them into a story, a rhyming poem or a comic strip. The pictures in the finished tale are your own photos. You pick the mood: funny, spooky (never gory) or mystery.

The screen is the shortest part of the experience on purpose:

The app sends you outside first. Each walk starts with a small mission, like "Photograph something that looks like a face" or "Find something red that isn't a stop sign".
Your phone is just the camera. The walk is the fun part, and the tale is the reward when you get back.
The tale is easy to read. Everything is written in simple English (short sentences, easy words, no idioms, about CEFR A2).

Who it's for:

Parents and kids who want a reason to go outside together, and a bedtime story starring the things they found.
Beginner English learners, who get a tale they can actually read, about things they saw themselves.
Anyone who needs an excuse to close the laptop for twenty minutes.

Demo

Live app: https://touch-grass-flutonp.onrender.com/

No API key? The app has a built-in demo (a canned walk with a park bench, a lamp post and a pigeon) and a gallery of sample tales.

How a tale gets made, step by step:

Connect the AI once. Paste a free Google AI Studio key, or point the app at LM Studio on your own computer.
Go for a walk with a random mission.
Add 5 to 10 photos.
Pick a mood and a format.
Press Make. A live panel shows each photo being checked and what was found in it ("park bench", "pigeon"…), then a sneak peek shows each scene as soon as it's written. A tale takes about 2 to 4 minutes.
Read it as a book or as slides, and publish it to your gallery if you like.

Code

ritikverma-chaibrew / week2

Touch Grass Tales 🌳

Go outside, photograph 5 to 10 random things, and Gemma AI turns them into a children's story, a rhyming poem or a comic strip (funny, spooky or mystery), illustrated with your own photos. Everything is written in simple words: short sentences, no idioms, about CEFR A2, so young readers and beginner English learners can follow it.

Using the site

Connect the AI once. Paste a free Google AI Studio key, or run Gemma locally with LM Studio. /setup.html walks through both.
Go for a walk. The Create page gives you a random photo mission (optional).
Add 5 to 10 photos.
Pick a mood (Funny, Spooky, Mystery) and a format (Story, Poem, Comic).
Press Make. Progress and time left stream live, a photo check panel shows each photo being checked and the items found in it, and a sneak peek shows each scene, verse or…

View on GitHub

How I Built It

The open-source AI core: Gemma, an open-weight model. Every word in a tale comes from Gemma. I use two Gemma 4 models, each for the job it's best at:

Task	Model	Why
Look at each photo	Gemma 4 26B-A4B	Fast mixture-of-experts model; one small (384px) photo at a time
Plan the plot and pick a photo for each moment	Gemma 4 26B-A4B	Fast, structured JSON planning
Write each scene or verse, then proofread and fix it	Gemma 4 31B	The best prose and rhyme
Write comic panel captions and speech bubbles	Gemma 4 26B-A4B	Fast; a caption plus up to two bubbles per panel

Many small calls, never one long reply. Instead of asking for a whole story at once, the app builds it piece by piece:

Look: one call per photo returns the objects in it.
Plan: one call writes the plot and decides which photo illustrates which moment.
Write: one call per scene (~170 words), stanza (4 lines) or comic panel, each building on the parts before it.
Edit: an "editor" call reviews the whole piece, and up to 3 weak parts are rewritten.
Readability check: this runs without the AI. It measures sentence length and long words, and any scene that's too hard is always sent back for a simpler rewrite.

Small calls keep the model focused, make each reply cheap to retry, and let the page show progress the whole time.

The rest of the stack:

FastAPI backend with MongoDB (Atlas when deployed) storing every pipeline step. If a step fails, Retry resumes from that exact step instead of starting over.
Live progress over Server-Sent Events: the photo-check panel, a countdown and the sneak peek all update as the tale is written.
Plain HTML, CSS and JavaScript frontend served by FastAPI, so it's one service to deploy on Render.
Gentle pacing for free API keys: calls go back-to-back, and only when a call is rejected does the app back off (30 s, then 60 s, then 90 s) before trying again.

Why Does Open Innovation Matter?

1. The same open model runs in the cloud or on your own machine.
Because Gemma's weights are open, the app has two interchangeable back ends: Google AI Studio (free key, nothing to install) and LM Studio, which runs Gemma locally. Switching is one click in the app, with no code changes. With LM Studio, your photos never leave your computer: the model that looks at your walk runs on your own hardware. A closed, API-only model can't offer that choice.

2. Your walk stays yours.
Photos of a walk can reveal where you live. So:

Location data is stripped: photos are re-encoded and their EXIF data (including GPS location) is removed on upload.
Photos are short-lived: they're deleted from the server after 24 hours.
Published tales stay with you: they're saved in your own browser's local storage, not on my server.
Your API key stays with you: it lives in your browser's local storage for 5 hours and is never stored on the server.

3. I pick the right model for each job.
Open weights come in many sizes, so the app uses a fast mixture-of-experts Gemma for looking and planning, and the large dense Gemma for writing and editing. In LM Studio you can swap in any Gemma build you've downloaded, per task, from a dropdown.

4. It costs nothing to run.
Gemma is free to use through a free AI Studio key, and completely free (and limitless) when run locally. A family can make a tale every weekend without a subscription.

Where open worked better than closed:

Prize Categories

Best Use of Gemma: every tale is written, planned and proofread by Gemma 4 (26B-A4B and 31B), and the photos are read by Gemma too. LM Studio runs Gemma locally.
Best Use of MongoDB Atlas: every tale's pipeline state lives in MongoDB Atlas, which is what lets a failed step resume exactly where it stopped. We don't save user generated tales.
Best Use of Render: the app is deployed as a single Render web service (render.yaml in the repo).

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?