DEV Community: Arun Mahajan

Lookout: The Offline AI Field Companion That Tells You to Put Your Phone Away

Arun Mahajan — Sat, 17 Oct 2026 16:50:35 +0000

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

What I Built

I built Lookout, a privacy-first Android field companion designed around one unusual success metric:

The AI should help you stop using the AI.

Most outdoor apps pull people deeper into their screens: more photos, more feeds, more badges, more notifications. Lookout takes the opposite approach. You ask a question about what you notice outdoors, receive one useful fact and a small observation mission, then the app encourages you to put the phone away and pay attention to the world around you.

It is for walkers, beginner birders, students, hikers, and anyone who wants technology to support outdoor curiosity without becoming another distraction.

The current prototype supports typed questions, on-device Android speech recognition when an offline language pack is available, bundled local species notes, observation missions, journaling, and PDF export.

┌─────────────┐
│ Ask once    │
└──────┬──────┘
       ▼
┌─────────────────────────┐
│ One fact + one mission  │
└──────┬──────────────────┘
       ▼
┌─────────────────────────┐
│ Put the phone away      │
│ and observe the world   │
└──────┬──────────────────┘
       ▼
┌─────────────────────────┐
│ Return and save notes   │
│ as a field journal      │
└─────────────────────────┘



The target is **less than 60 seconds of total screen time per session.**

- Source code: Lookout on GitHub — `https://github.com/aun009/hacktober-week-1`

A good demo flow is:
1. Open Lookout in **Airplane Mode**.
2. Ask a typed or offline speech question.
3. Show the one-fact response and observation mission.
4. Return to the app, add a journal note, and export the PDF.

## Code

The project is open source under the **Apache 2.0 License**.

Key parts of the project:
- Android app and Compose UI
- Offline species-pack retrieval
- Mission system
- Safety rules
- Field journal and PDF export
- Architecture documentation

You can embed the repo directly with:

{% github `[your-github-username]/[repo-name]` %}

## How I Built It

Lookout is built with **Kotlin and Jetpack Compose** for Android. Its core design avoids a cloud-dependent loop: local field notes, missions, journal entries, and PDF export work without Lookout sending data to a server.

text
User input
│
▼
Local species notes ──► Safety rules ──► One useful response
│ │
▼ ▼
Observation mission ◄────────────────── Put phone away
│
▼
Debrief → Field journal → Local PDF export




The repository also contains interfaces and architecture for a fully local open-source AI stack:

| Capability | Open technology planned / integrated architecture |
|---|---|
| Local language model | Qwen via llama.cpp |
| Speech-to-text | whisper.cpp |
| Text-to-speech | Piper |
| Voice activity detection | Silero VAD |
| Noise reduction | RNNoise |
| Image understanding | MobileCLIP |
| Local data | Room / SQLite |
| UI | Kotlin + Jetpack Compose |

I deliberately designed the app to **fail safely**. If a model-backed answer is unavailable, Lookout says so rather than inventing an identification. The current build does not bundle pretrained model weights or enable live camera and ambient bird-call identification yet; those are clearly documented as next steps in the repository.

Safety is especially important outdoors. Lookout's rule layer flags potentially dangerous situations involving toxic plants, mushrooms, or wildlife and avoids presenting an AI response as permission to eat, touch, or approach something.

## Why Does Open Innovation Matter?

Open innovation is what makes Lookout's purpose possible.

A closed, cloud-only AI API would make an outdoor companion depend on signal, credentials, recurring cost, and a server connection. That is exactly the wrong trade-off for a trail, park, forest, or rural area.

Open-source AI makes it possible to build toward:

- **Offline use:** Local models can run where internet access is unreliable or unavailable.
- **Privacy by architecture:** Voice and observation data can stay on the device instead of being uploaded to a third-party server.
- **Model choice:** The architecture is designed so models can be swapped rather than locking the app to one provider.
- **Transparency:** The safety rules, species-pack workflow, and system behavior are visible in the codebase.
- **Lower barriers to experimentation:** Builders can adapt Lookout for a local region, language, or species pack without needing permission from a closed API provider.

For this project, open source is not just a licensing choice. It is the reason the product can aim to be **private, resilient, adaptable, and useful outdoors.**

## Prize Categories

I am entering the overall **Hacktoberfest Open-Source AI Challenge: Week 2 — Side Hustle** category.

I am not claiming a partner-technology category because this version does not use a listed partner technology.

## Team

Built by [@aun009](https://dev.to/aun009).

---

Thanks for reading — and if you try Lookout, I hope it gives you a reason to look up from your phone.

VivaShield AI: I built the open-source viva defense tool that predicted 4 out of 5 actual examiner trap questions

Arun Mahajan — Thu, 15 Oct 2026 17:03:07 +0000

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

What I Built

VivaShield AI — an open-source capstone viva defense and examiner trap predictor that runs 100% locally using Google Gemma 2 via Ollama.

You paste your engineering capstone project's README, tech stack, and a key code snippet. A locally-running Gemma 2B model (Google's open-weight family) reads it and generates:

5 Ruthless Examiner Trap Questions — the exact uncomfortable questions external examiners ask ("Why did you use float64 for money amounts instead of integer cents? Have you heard of IEEE 754 precision errors?"), with bulletproof model defenses
4 Architecture Deep-Dive Q&As — for when examiners probe data flow, transactions, and error handling
3 What-If Chaos Scenarios — "What happens if 10,000 concurrent users hit your SQLite database?"
1-Page Printable Hallway Cheatsheet — to read 5 minutes before walking into the examination room
GitHub Repo Importer — paste a public repo URL and the app fetches the README + file tree automatically
Readiness Score — a 0-100 score with risk tagging (Low / Moderate / High)

Who pays for this? Final-year engineering students and Xerox/cyber cafe shops near campuses that print capstone binders. Students already pay Rs. 500-2,000 for bound project reports. Offering a laminated VivaShield defense sheet as a Rs. 49 add-on is a zero-friction impulse buy, with almost no marginal cost when using open-weight AI.

Demo

Here is what a live Gemma 2B output looks like for a student's Go+Kafka payment gateway capstone:

Examiner Trap generated by Gemma:

"Why did you use float64 to store monetary amounts in your wallet ledger? Have you tested what happens with repeated addition of 0.1?"

Bulletproof defense generated:

"In our prototype we used float64 for simplicity, but we are aware of IEEE 754 precision issues with floating-point arithmetic for money. A production-grade version would store amounts as integer cents (int64) or use a fixed-precision decimal library to guarantee exact arithmetic."

The student who tested this was asked exactly this question by their external examiner.

Run it locally in 3 commands:

git clone https://github.com/aun009/week-2-VivaShield.git
cd week-2-VivaShield && ollama pull gemma2:2b
./run.sh   # opens at http://localhost:8000

Code

aun009 / week-2-VivaShield

🛡️ VivaShield AI

Open-Source Capstone Viva Defense & Examiner Trap Predictor

Built for the Hacktoberfest Open-Source AI Challenge: Week 2 (Side Hustle).
Powered by Google Gemma 2 running locally via Ollama with $0.00 marginal inference costs.

💡 The Problem & The Side Hustle

Over 1.5 million engineering and computer science students graduate every year across universities (SPPU, VTU, Anna Univ, IITs, etc.). Every single one must face an external viva defense of their final-year capstone project.

The terror is universal:

External examiners deliberately probe for copied code, unjustified tech choices ("Why did you use MongoDB instead of Postgres for relational data?"), and concurrency bottlenecks.
Students know how to code their prototype, but freeze when grilled on low-level architectural justification.
Students and tuition/Xerox shops already spend ₹500 to ₹2,000 for bound project reports and slide decks.

💰 The Business Model: ₹49 ($0.59) Impulse Micro-SaaS

Direct Student…

View on GitHub

The whole backend is a single 280-line app.py — FastAPI + Ollama. No databases, no auth, no external APIs except the optional GitHub README fetcher. The Gemma inference call:

payload = {
    "model": "gemma2:2b",   # Open-weight Google model, runs on a 4GB laptop
    "prompt": f"{system_prompt}\n\nUser Project Input:\n{user_prompt}",
    "stream": False,
    "options": {"temperature": 0.4, "top_p": 0.9, "num_predict": 1500}
}
res = requests.post("http://localhost:11434/api/generate", json=payload, timeout=45)
raw = res.json()["response"]
dossier = json.loads(re.search(r"\{.*\}", raw, re.DOTALL).group(0))

The prompt instructs Gemma to respond exclusively in a JSON schema with 7 dossier sections. No JSON mode API needed — the structured system prompt + temperature 0.4 reliably produces parseable output.

One safety net: if Ollama is not running yet, a Hybrid Viva Engine generates heuristic-based trap questions from the tech stack tokens — so the app never crashes during a live demo.

How I Built It

Open-source AI stack:

Google Gemma 2 2B (open-weight, Apache 2.0) — the inference core
Ollama — local model server, serves Gemma via REST at localhost:11434
FastAPI — Python backend (one file)
Vanilla CSS (Minimal & Accessible) — distraction-free, zero-emoji UI with clean print layout
GitHub REST API — pulls public README + file tree for the repo importer

The examiner persona system:

The system prompt supports three tunable examiner personas:

Strict External — IIT/NIT professor checking if students actually wrote the code
Standard University — SPPU/VTU syllabus committee style questions
Industry CTO — Principal Architect grilling on race conditions and production scaling

Each persona changes the angle of generated trap questions using the same model weights. This is only possible because Gemma's weights are open — with a closed API, I would be paying extra tokens just to experiment with prompt styles.

Why Does Open Innovation Matter?

This is where it gets concrete. At Rs. 49 ($0.59) per student, here are the unit economics:

	Closed API (GPT-4o)	Open-Weights (Gemma 2B)
Cost per run	~Rs. 18.50 ($0.22)	Rs. 0.00
Gross margin @ Rs. 49	62% (shrinks as API prices change)	98.4%
Student code privacy	Code uploaded to third-party cloud	Never leaves localhost
Offline campus use	Fails without WiFi	Works with no internet

A closed-API approach eats 38% of revenue per run before hosting. With Gemma running locally, the only fixed cost is optionally a $5/month VPS for students who do not want to install Ollama. At Rs. 49 per student, break-even is 10 runs.

But the most important reason is student IP privacy. Engineering capstone projects often contain unpublished algorithms and code under NDA from industry partners. Uploading it to a cloud LLM risks it being logged and potentially appearing in future training data. With Gemma on localhost, the code never leaves the machine. For students working on industry capstone projects under NDA, that is a hard requirement.

And finally, fine-tuning. I can collect university-specific questions from alumni and train a LoRA adapter on top of Gemma 2B for SPPU's specific external examination patterns — something a closed API makes impossible.

My First User

I gave the live tool to a final-year BE Computer Science student (IoT + CNN capstone) at a Pune college the day before their viva.

VivaShield generated 5 trap questions. Their examiner asked 4 out of 5.

The student's reaction on WhatsApp the next day:

"Bhai yeh actually kaam kiya. Pehle question same nikla. Rs. 49 toh deta re."

(Translation: "Bro this actually worked. The first question was exactly the same. I will pay Rs. 49 for sure.")

What they asked for next: Hindi-language output and a version that reads the project slides directly.

Prize Categories

Best Use of Gemma — Gemma 2 (2B) is the inference core. The app detects and defaults to gemma2:2b, falls back to any available Ollama model.
Best Use of Render — render.yaml and Dockerfile included for 1-click deployment.

Lookout: The Offline AI Field Companion That Tells You to Put Your Phone Away

Arun Mahajan — Fri, 09 Oct 2026 07:22:30 +0000

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

What I Built

I built Lookout, a privacy-first Android field companion designed around one unusual success metric:

The AI should help you stop using the AI.

It is for walkers, beginner birders, students, hikers, and anyone who wants technology to support outdoor curiosity without becoming another distraction.

┌─────────────┐
│ Ask once    │
└──────┬──────┘
       ▼
┌─────────────────────────┐
│ One fact + one mission  │
└──────┬──────────────────┘
       ▼
┌─────────────────────────┐
│ Put the phone away      │
│ and observe the world   │
└──────┬──────────────────┘
       ▼
┌─────────────────────────┐
│ Return and save notes   │
│ as a field journal      │
└─────────────────────────┘



The target is **less than 60 seconds of total screen time per session.**

- Source code: Lookout on GitHub — `https://github.com/aun009/hacktober-week-1`

A good demo flow is:
1. Open Lookout in **Airplane Mode**.
2. Ask a typed or offline speech question.
3. Show the one-fact response and observation mission.
4. Return to the app, add a journal note, and export the PDF.

## Code

The project is open source under the **Apache 2.0 License**.

Key parts of the project:
- Android app and Compose UI
- Offline species-pack retrieval
- Mission system
- Safety rules
- Field journal and PDF export
- Architecture documentation

You can embed the repo directly with:

{% github `[your-github-username]/[repo-name]` %}

## How I Built It

Lookout is built with **Kotlin and Jetpack Compose** for Android. Its core design avoids a cloud-dependent loop: local field notes, missions, journal entries, and PDF export work without Lookout sending data to a server.




The repository also contains interfaces and architecture for a fully local open-source AI stack:

| Capability | Open technology planned / integrated architecture |
|---|---|
| Local language model | Qwen via llama.cpp |
| Speech-to-text | whisper.cpp |
| Text-to-speech | Piper |
| Voice activity detection | Silero VAD |
| Noise reduction | RNNoise |
| Image understanding | MobileCLIP |
| Local data | Room / SQLite |
| UI | Kotlin + Jetpack Compose |

I deliberately designed the app to **fail safely**. If a model-backed answer is unavailable, Lookout says so rather than inventing an identification. The current build does not bundle pretrained model weights or enable live camera and ambient bird-call identification yet; those are clearly documented as next steps in the repository.

Safety is especially important outdoors. Lookout's rule layer flags potentially dangerous situations involving toxic plants, mushrooms, or wildlife and avoids presenting an AI response as permission to eat, touch, or approach something.

## Why Does Open Innovation Matter?

Open innovation is what makes Lookout's purpose possible.

A closed, cloud-only AI API would make an outdoor companion depend on signal, credentials, recurring cost, and a server connection. That is exactly the wrong trade-off for a trail, park, forest, or rural area.

Open-source AI makes it possible to build toward:

- **Offline use:** Local models can run where internet access is unreliable or unavailable.
- **Privacy by architecture:** Voice and observation data can stay on the device instead of being uploaded to a third-party server.
- **Model choice:** The architecture is designed so models can be swapped rather than locking the app to one provider.
- **Transparency:** The safety rules, species-pack workflow, and system behavior are visible in the codebase.
- **Lower barriers to experimentation:** Builders can adapt Lookout for a local region, language, or species pack without needing permission from a closed API provider.

For this project, open source is not just a licensing choice. It is the reason the product can aim to be **private, resilient, adaptable, and useful outdoors.**

## Prize Categories

I am entering the overall **Hacktoberfest Open-Source AI Challenge: Week 1 — Touch Grass** category.

I am not claiming a partner-technology category because this version does not use a listed partner technology.

## Team

Built by [@aun009](https://dev.to/aun009).

---

Thanks for reading — and if you try Lookout, I hope it gives you a reason to look up from your phone.

Udhaar: a private voice khata for a kirana shopkeeper

Arun Mahajan — Sat, 03 Oct 2026 12:55:47 +0000

Udhaar: a private voice khata for a kirana shopkeeper

Submission for the Hacktoberfest Weekend Challenge: Build for a Friend.

What I built

I built Udhaar for my friend Purushottam, who runs a neighbourhood kirana shop in Pune. His recurring problem was recording small customer debts quickly while serving the next person. Paper notes get lost, and a cloud app is a poor fit for sensitive customer names and balances.

Udhaar lets the shopkeeper speak or type a Hindi, Marathi, or Hinglish entry such as “Ramesh ji ko 340 ka samaan udhaar”. It proposes a structured entry, asks the shopkeeper to confirm it, and then updates a simple khata.

It also shows balances, a monthly summary, and polite WhatsApp reminder links. The links are always manually opened and sent; the app never messages a customer automatically.

Demo

Demo video: https://youtu.be/8X4TxyVbnI8
Repository: https://github.com/aun009/udhaar
Local demo: UDHAAR_MOCK=1 uvicorn app.main:app --host 0.0.0.0 --port 8000, then open http://127.0.0.1:8000.

The mock mode runs without a GPU, microphone, or network model service. The production path uses local Whisper and Ollama instead.

How I built it

The system is a small FastAPI application with SQLite storage and a single mobile-friendly HTML page:

Audio is transcribed locally with faster-whisper when voice mode is enabled.
An open-weight Qwen instruct model served by Ollama converts the transcript into a strict JSON label.
The UI displays the proposed customer, amount, type, and note for confirmation.
Confirmed entries are stored locally in SQLite and used for balances and summaries.
A deterministic Hindi/Marathi reminder template produces a WhatsApp link for manual sending.

The repository also includes a synthetic Hindi/Marathi/Hinglish dataset generator, an evaluation runner, and a heuristic fallback so the core demo remains usable when Ollama is unavailable.

Why open innovation mattered

Open models made the important parts adaptable instead of hiding them behind a remote API. Customer names and dues can remain on the shop laptop, amount-word examples can be added to the training set, and the parser model can be swapped or fine-tuned. Once the local runtime is installed, there is no per-entry API bill and the workflow can continue when the internet is unreliable.

That control has a cost: local model setup is more involved, and zero-shot parsing is less robust than a strong hosted model on messy speech. For this friend and this data, keeping the ledger private and editable was the better trade.

Results and limitations

The reproducible heuristic baseline currently scores:

Split	Examples	Exact JSON	Customer	Amount	Type	Valid JSON
Synthetic test	400	16.00%	47.50%	48.00%	94.00%	100.00%
Unseen templates	120	10.00%	25.83%	53.33%	93.33%	100.00%

The second row should be read as 120 examples, 10.00% exact JSON, 25.83% customer, 53.33% amount, 93.33% type, and 100.00% valid JSON. These are baseline numbers, not a claim that the parser is solved. Ollama, fine-tuning, and real-audio rows are intentionally omitted until they are run locally.

Open source and code

Source: https://github.com/aun009/udhaar
Evaluation details: eval/RESULTS.md
Training notes: train/README.md

My agent session

[Optional: add the DevRelay agent-session link or remove this section.]

Partner categories

[List only categories that actually apply, or remove this section.]