Create account

DEV Community

Musaddiq Ahmed Khan

Posted on Oct 25

MVP — Minimum Viable Person: a survival tracker that knows how long you'll survive

#devchallenge #hf26challenge #gemma #flutter

Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady 🦥

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

Two buttons. That's the whole app.

MVP — Minimum Viable Person is a survival tracker that knows how long you'll survive.
Tap ATE when you eat, tap DRANK when you drink.

The app converts each into survival hours using the pop-science "rule of threes" (~3 days without water, ~3 weeks without food). Two tanks — food and water — drain in real time, counting down every second. When they run low, a notification nags you, the buttons pulse, and a lazy AI roommate comments on your continued existence.

It rewards laziness twice over: the tracking costs one tap, and everything the AI writes assumes you won't try.

▶ Video demo (full walkthrough, airplane mode on): https://drive.google.com/file/d/1q6PtO1c3dP3ZCMznCAiQaDVae_gvM1ou/view?usp=drivesdk

Code

Musaddiq625 / mvp_minimum_viable_person

a survival tracker for people who cannot be bothered — offline-first Flutter app powered by on-device Gemma 3n

MVP — Minimum Viable Person

knows how long you'll survive.

Built for Hacktoberfest 2026 — Week 3: Slow and Steady.

Two buttons. That's the whole app.

Tap ATE when you eat, tap DRANK when you drink
The app tells you how long you'd survive if you stopped caring entirely
Powered by the pop-science "rule of threes" (≈3 days without water ≈3 weeks without food)
Backed by a local, on-device, open-weights AI model — no cloud no account, no effort

Built for Hacktoberfest — DEV Open-Source AI Challenge, Week 3: "slow and steady." Nothing is slower or steadier than a person who barely moves.

The joke, taken seriously

Every health app assumes you want to try. This one assumes you don't — and that's the whole product.

Two tanks: food and water, measured in survival hours
Tanks decay in real time — watch the countdown tick every second
A…

View on GitHub

How I Built It

Flutter Android app, offline-first. The AI is Gemma 3n E2B-it LiteRT Preview (~3 GB int4) running on-device via flutter_gemma → MediaPipe LLM Inference / LiteRT with a GPU delegate. After the one-time download it's 100% offline — airplane mode, everything works.

What the model actually does:

Writes every persona line, streamed token-by-token — you watch it type, signed — gemma, on-device
Writes the weekly report — a shareable card generated live
Gates the entire app — verified by real inference, not a file-existence check

What it deliberately doesn't do: survival math. That's pure Dart — deterministic, test-covered, clamped. The model's output is parsed and validated before it can touch state, because a creative model should write jokes, not arithmetic.

Lazy-engineering details worth mentioning:

Serialized inference — MediaPipe can't run concurrent sessions, so every generation takes a mutex; cancelled streams drain to completion before the session closes
5s debounce — spam-tapping gets a canned clapback instantly, no inference wasted
Chunky 3D buttons that press like an arcade machine — haptics postponed, in the spirit of the app
Resumable model download — a 3 GB file survives crashes; the download→install handoff was the single highest-pressure moment in the app (ask me about the WorkManager foreground-service crash)

Why Does Open Innovation Matter?

This app could not exist the same way on a closed API:

It actually works offline. Airplane mode is a feature, not an edge case — an open-weight model makes "nothing leaves the phone" a fact instead of a privacy policy.
What you eat is nobody's business. A tracker logging your meals has no business shipping that to someone's server. On-device inference means there is no server.
Zero marginal cost. The laziest possible economics: no API key, no billing alert, no rate limit. Download once, run forever, free.
The model is swappable. The persona is a prompt, not a product — drop in a different open-weight model and the app gets a new personality.

Open innovation isn't a garnish here — the open model is load-bearing infrastructure that happens to write dry one-liners.

The Lazy Payoff

Interaction cost: ~1 second. One tap, three times a day, versus any food journal that wants you to weigh your lunch.
Forgives skipping. Miss a whole day and gap-fill assumes you self-maintained — the only health app that rewards not logging.
Doesn't even require opening it. Notification quick actions log the meal from the shade.
The AI does the writing so you can do the lying around. Every acknowledgement, report, and sarcastic worry is generated, not templated.