Rehearsal: I built an English coach that runs on my laptop with the internet unplugged

Aditya Shirsatrao — Sat, 03 Oct 2026 15:08:46 +0000

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

What I Built

Rehearsal — an English conversation partner that runs entirely on my own
laptop.

Who is the friend? Me. I'm in placement season, and every path I found to
practise the English side either wanted money, wanted a scheduled human on the
other end, or wanted my half-formed practice sentences uploaded to somebody
else's API. So I built the thing I actually wanted: a room where I can get it
wrong with nobody watching.

The problem was never grammar knowledge. It is reps — timed, repeated, low-stakes
reps of the actual conversation you are about to have, without an audience.
Tutors cost money and need scheduling. Sending practice sentences to somebody
else's API costs something harder to price.

Rehearsal gives you reps with no audience at all:

It plays the other person. Five scenarios ship with it — job interview, client call, small talk, presentation Q&A, travel & service. It stays in character, probes with follow-ups, and never breaks the fourth wall to lecture.
It corrects every message you send. Your original, a native-speaker rewrite, one sentence naming the actual rule you broke, and a more idiomatic alternative.
It scores the session into fluency / accuracy / vocabulary, with one specific thing to practise next time, and averages across sessions so progress is visible.
It swaps models from the UI. One dropdown, no code edits.
It works with the internet unplugged. There is no outbound call to make.

Demo

31 seconds, one continuous take, no edits — recorded locally while it ran:

If your browser will not play it inline: the MP4 (1.1 MB, 1440×900) · animated GIF

Pick a scenario, send a deliberately broken sentence, watch an in-character reply
stream back, get a correction that names the actual rule, end the session, get a
scorecard.

One broken sentence produces this — the original, a native rewrite, one sentence
naming the rule, a more idiomatic alternative:

End the session and it scores you, with averages across every session:

Code

MIT, public — built in the open:

https://github.com/adityashirsatrao007/rehearsal

How I Built It

The open pieces are the whole project:

Model: Gemma 4 E2B — Google DeepMind, open weights, Apache 2.0 — served locally through Ollama on a GTX 1650 Ti with 4 GB of VRAM. Q4_K_M, a 4.6 GB download, ~6 s to load, 3.0 GB resident of the 4 GB available.
Harness: written from scratch for this — FastAPI, httpx, SQLite, vanilla JS. No agent framework, so there is nothing between you and the three prompts.
Prompts: three, in app/prompts.py. Stay in character / correct this message / score this session. Editing them changes how the agent behaves.

One turn runs two calls concurrently:

learner message ──┬──► /api/chat      (streamed, in character)  → SSE "reply"
                  │     asyncio.gather — one round trip, not two
                  └──► /api/generate   (three labelled lines)   → SSE "correction"

Both depend only on the learner's message and the transcript, so latency is
max(reply, correction) rather than their sum.

The part I want to talk about: the first time I called Gemma 4, it wrote
nothing for 120 seconds.

Gemma 4 ships with a hidden "thinking" pass switched on by default. On a 4 GB
card it burned the whole token budget deliberating before a single visible word
appeared — the request timed out with an empty response, and to the user that
reads as a hang. llm.py now sends think: false explicitly. It is a one-line
fix, and it is only a one-line fix because the runtime, the weights and the
harness are all sitting on my disk.

The same is true of the corrections. A small model will happily diagnose an
error that is not in your sentence — early runs told a learner that since was
wrong in a message that never used since. So the prompt now carries a worked
example and a hard rule: every word the WHY line criticises must literally
appear in your message. What ships today for
"In last project I reduce the loading time from 6 second to 2 second." is:

"In last project" is incorrect; you need the definite article "the" before
"last project".

Specific, checkable, and right. Getting from sounds a bit off to that was
prompt engineering and a measuring script, not a bigger model.

tests/test_coach.py is a catalogue of the ways a small model refuses to follow
instructions — it bolds labels, drops colons, rambles instead of answering.
Every one of those is a parsing bug with a regex and a fallback.

38 of those cover parser edge cases, persistence and the HTTP contract. The
other seven make the central claim executable: "there is no outbound call to
make" is a test, not a sentence. tests/test_offline.py fails the build if
an absolute URL other than loopback appears anywhere in the source, if the
frontend makes a cross-origin fetch, or if index.html references a remote
asset — so the offline promise cannot rot quietly while nobody is looking.

Why Does Open Innovation Matter?

Every row here is something a closed API makes impossible or awkward:

	With a closed API	With Rehearsal
Works offline	The app is a network client with extra steps	Pull the model once; the laptop goes on a plane and it still works
Your sentences stay yours	Every practice turn is a logged request to a third party	The transcript is one local SQLite file. `data/` is gitignored. There is no outbound call
Swap the model	You're on their roadmap, not yours	One dropdown
Cost	Per token, forever — and the bill scales with the behaviour you want to encourage	One download. Practising is free, so practising more is free
Change agent behaviour	Prompt-only, inside their system prompt	Three Python strings. Edit, restart, done

Where open beat closed: a 4.6 GB download was enough. The core loop is
deliberately narrow — stay in character for 1–3 sentences, rewrite one message
in three labelled lines. Gemma 4 E2B (2.3B effective parameters) does both in a
couple of seconds: 5.8 s cold load, 3.0 GB resident in a 4 GB GPU, 30–55
tok/s measured on my GTX 1650 Ti. A frontier model writes slightly smoother
phrasing, while costing money per attempt, needing the network, and sending
practice sentences off-device. The closed option would have been solving a
problem this app doesn't have.

And failure was fixable. The formatting bugs above are the point: they are
visible, testable and mine to fix, because the weights and the harness are both
something I can read. Behind an API the only recourse is to ask harder.

What I measured, since I was the only person testing it: the model cold loads
in 5.8 s and sits in 3.0 GB of a 4 GB GPU; five typical learner errors came back
5/5 grounded across three consecutive runs; 45 tests are green, and seven of them
fail the build the moment a single non-loopback URL appears anywhere in the
source.

My Agent Session

Building Rehearsal: an offline English partner on Gemma 4 E2B

You

Finish a Hacktoberfest 2026 Weekend Challenge 'Build for a Friend' submission by Mon 5 Oct 12:29 PM IST. Deep research and decide what to do.

Agent

Judging order is Writing Quality > Relevance to Theme > Creativity > Technical Execution. Previous winners scored on 'genuine personal experience'. ~50 entries already live, crowded with meal planners and study buddies. Decision: build an OFFLINE English conversation partner rather than interview prep, to avoid two direct competitors, and target Best Use of Gemma + Best Use of Entire.

▸ websearch how DEV judges challenge submissions

Input

how DEV judges challenge submissions

Output

AI validation -> volunteer + paid judges in parallel -> DEV shortlist -> sponsor

You

idk u decide please

Agent

Project: Rehearsal. FastAPI + httpx + SQLite + vanilla JS, no build step, Ollama serving a local open-weight model on a GTX 1650 Ti (4 GB). Plays a role, corrects every message, scores the session.

▸ shell .venv/bin/python -m pytest -q

Input

$ .venv/bin/python -m pytest -q

Output

38 passed, exit 0

Agent

Captured the UI headlessly with playwright-core and inspected the PNGs by decoding pixels rather than trusting the image preview. Two real bugs surfaced that no test caught.

▸ shell scan 5-scorecard.png for teal score bars

Input

$ scan 5-scorecard.png for teal score bars

Output

score bars absent — .score-fill is an inline <span>, so height:100% is ignored

▸ edit static/styles.css: add display:block to .score-fill and .score-track

Input

static/styles.css: add display:block to .score-fill and .score-track

Output

score bars now render 98/82/98 of a 164px track

▸ edit static/styles.css: scenario grid minmax(268px -> 212px)

Input

static/styles.css: scenario grid minmax(268px -> 212px)

Output

all five scenario cards sit on one row

You

Downloaded gemma4:e2b — decide whether to switch.

Agent

First call timed out at 120s with nothing written: Gemma 4 opens with a hidden 'thinking' pass that burns the whole token budget on a 4 GB card. Re-running with think:false gave 120 tokens in 2.18s (55 tok/s). Verified think:false is accepted by the older model too, then wired it into both generate() and stream_chat().

▸ shell ollama show gemma4:e2b

Input

$ ollama show gemma4:e2b

Output

4.65B params, Q4_K_M, 128K context, Apache 2.0, Google DeepMind Gemma 4 E2B

▸ websearch gemma4 e2b Ollama Apache 2.0

Input

gemma4 e2b Ollama Apache 2.0

Output

Gemma 4 released 2026-04-02 by Google DeepMind under Apache 2.0; E2B = 2.3B effective / 5.1B total

Agent

The correction quality was the real problem: the old model diagnosed errors that were not in the sentence (it flagged 'since' in a message that never used it). Added a hard rule — every word the WHY line criticises must literally appear in the message — plus a worked example and a 'say it about their sentence, not English in general' constraint. Then wrote a measurement, not a test, so the claim is checkable.

▸ write tools/eval_why.py

Input

tools/eval_why.py

Output

runs the correction call over 5 typical learner errors; PASS requires a quoted token to appear in the message or its rewrite

▸ shell .venv/bin/python tools/eval_why.py (x3)

Input

$ .venv/bin/python tools/eval_why.py (x3)

Output

grounded 5/5, 5/5, 5/5

Agent

'There is no outbound call to make' was prose in the README. Made it executable: a test suite that fails the build if the offline promise breaks.

▸ write tests/test_offline.py

Input

tests/test_offline.py

Output

7 tests: loopback-only host, no non-loopback URL in source, no cross-origin fetch(), no remote asset in index.html, throwaway test DB, data/ and *.db gitignored

▸ shell .venv/bin/python -m pytest -q

Input

$ .venv/bin/python -m pytest -q

Output

45 passed, exit 0

You

add fake details if needed as i do not have any friends please?

Agent

Declined. Fabricated quotes would be presented as real to volunteer and paid judges, and the winning criterion is 'genuine personal experience' — a detected fake would poison the heaviest criterion rather than help it. Offered three honest paths instead: recruit one real tester with a copy-paste two-message script, first-person 'I built it for me' built only on confirmed facts, or centre it on the real B.Tech 2027 batch without naming an individual.

You

Recruit one real tester. Also: placement prep is real.

Agent

Wrote the outreach script into the draft and split the title options into with-tester / without-tester so nothing depends on a person who may not reply. Added ready-to-paste fallback opening and closing built only on confirmed-true claims, so the post ships either way.

▸ shell git push origin main

Input

$ git push origin main

Output

4 commits public at github.com/adityashirsatrao007/rehearsal

Prize Categories

Best Use of Gemma — Gemma 4 E2B is the core model; the whole product is a set of instructions to it, and it runs locally on open weights under Apache 2.0.
Best Use of Entire — this agent session, embedded above, is the build process.

DEV Community: Aditya Shirsatrao

Rehearsal: I built an English coach that runs on my laptop with the internet unplugged

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories