DEV Community: Shikha Singh

LazyStudy: My Idea for an Offline AI Study Buddy

Shikha Singh — Sun, 25 Oct 2026 11:58:58 +0000

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

What I Plan to Build

As a student, I know how time-consuming it can be to go through lengthy PDFs, prepare revision notes, and create questions for practice. Sometimes, the hardest part of studying is not learning the material but organizing it all.

That is why I want to build LazyStudy — an offline AI study buddy that does the repetitive preparation work for you.

The idea is simple: upload a study PDF and let AI help turn it into:

Short notes: Simplify lengthy chapters into key points.

Flashcards: Generate question-and-answer cards for revision.

Practice quizzes: Create questions based on the document.

Revision plans: Break the material into smaller, manageable study sessions.

The goal is not to replace learning or make students lazier about understanding concepts. Instead, I want to reduce the time spent preparing to study so that students can spend more time actually learning.

LazyStudy is currently a project proposal, and I plan to develop it further.

How I Plan to Build It

My plan is to use Ollama with an open-weight language model to power the study assistant locally.

The proposed workflow is:

A student selects a PDF from their computer.

A PDF-processing library extracts the document's text.

The extracted text is passed to a locally running language model.

The model generates summaries, flashcards, quizzes, or a revision plan based on the student's request.

The results are displayed in a simple interface that students can use for revision.

I want to keep the architecture lightweight and start with a basic prototype before adding more features.

The important part is that the AI inference is intended to happen on the student's own computer. After downloading the model and setting everything up, the core workflow should be able to operate without an internet connection, subject to the chosen model and its local dependencies.

Why Does Open Innovation Matter?

For a tool that works with personal study materials, I believe students should have more control over their documents and the AI they use.

Using a locally running, open-weight model could offer several advantages:

Privacy: Study documents would not need to be uploaded to a third-party AI API for inference.

Offline access: Once the model and required software are installed, students could use the core features without a continuous internet connection.

Flexibility: I could experiment with different models and choose one that fits the available hardware and the quality of results I need.

Lower ongoing costs: Local inference avoids per-request charges from a hosted AI API, although the computer still uses electricity and requires suitable hardware.

A closed API might be convenient, but it could introduce recurring costs and a dependency on an external service. With LazyStudy, I want local AI to be central to the design rather than an afterthought.

For me, open innovation means having the freedom to experiment, learn how the system works, and adapt it to students' needs.

The Lazy Payoff

The payoff I am aiming for is simple: less time organizing study materials and more time learning.

I have not measured any time savings yet because LazyStudy is still at the idea stage. Once I build the prototype, I want to compare the time it takes to prepare notes and practice questions manually with the time it takes using LazyStudy.

My goal is to make studying feel more manageable, especially when there is a lot of material to cover and not much time to prepare.

*What's Next?
*
The first milestone is a small, functional prototype that can process one PDF and generate useful revision notes using a local model. From there, I hope to add flashcards, quizzes, and revision planning.

This is my starting idea for Slow and Steady: a small tool that uses open-weight AI to take some of the repetitive work out of studying.

Golden Hours

Shikha Singh — Sun, 11 Oct 2026 06:20:32 +0000

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

A team project by @shikha_singh_20 and @shreyash_magar.

What I Built

Golden Hour is a calm, mobile-first web app that nudges you to step outside around sunrise and sunset.

You pick sunrise, sunset or both, and how many minutes ahead you want a reminder. When it's time, your phone gets a notification such as "Golden hour in 20 minutes. Take your chai out to the terrace." You go to your balcony or terrace, take one photo of the sky, and enjoy a chai, coffee or snack. Then you tap Done. The check-in is recorded, your streak goes up, and you put the phone away.

It's for people who spend long hours on screens and for people in apartments, where "going outside" can simply mean going to the balcony. The screen is the shortest part of the experience: a short setup, and a tap on Done.

Code

[https://github.com/shikha-code404/golden-hour]

How I Built It

Open-source pieces

Gemma (open-weight), run locally through Ollama. We used it to write the reminder messages, treat suggestions and completion lines. We generate them with scripts/make_nudges.js, review them by hand, and save them to data/nudges.json. The server picks lines from that file, so the live app doesn't need a model running.
SunCalc calculates sunrise, sunset and golden hour offline from latitude, longitude and date.
Node.js and Express for the server, and Web Push with VAPID keys for notifications. The frontend is a plain-JavaScript PWA with a service worker.
MongoDB Atlas stores subscribers, reminders and check-ins.

How it works

You allow notifications and share your location. The app stores your timezone too.
A scheduler calls our /api/tick endpoint every minute with a secret header. The endpoint plans upcoming reminders from SunCalc and sends the ones that are due.
Tapping the notification opens an "outside" screen with the camera, a treat picker and a Done button.
Your photo is saved in your phone's IndexedDB and is never uploaded. The server only stores the check-in (date, kind and optional treat) to count your streak.

Data model: subscribers (push endpoint and keys, location, timezone, preferences, lead time), reminders (kind, event time, fire time, sent time) and checkins (kind, local date, optional treat).

Hosting: Render runs the web service, defined in a render.yaml Blueprint with a /health check and secrets entered in the dashboard. Render is only hosting. Any server with Node.js and MongoDB can run the app.

How we built it: We used Antigravity as a coding assistant and built the app in phases (database, sun-time module, API, frontend, messages, deployment), checking each step ourselves.

Why Does Open Innovation Matter?

We could read and curate every message. Because Gemma is open-weight and ran on our own machine, we generated the messages, deleted the odd ones, and shipped a fixed set. We aren't relying on a hosted model whose wording or terms could change.
No per-use AI cost. The model runs once, offline, on a laptop. There are no third-party AI API keys, so the AI part of the app costs nothing to run. (Web Push and MongoDB Atlas still need their normal service credentials.)
Privacy by design. Photos of someone's home never leave their phone, and sun times are calculated with an open library instead of sending the person's location to a sun-times API.
Swappable and extensible. When a better small model appears, we can regenerate the messages and compare. Anyone can fork the repo, edit data/nudges.json, and add their own language or tone.

Prize Categories

We have used Gemma , Render , MongoDB Atlas for building this project