DEV Community: Shubham Hagawane

Terminal Déjà Vu: I Got Tired of Solving the Same Error Twice, So My Terminal Now Remembers

Shubham Hagawane — Fri, 23 Oct 2026 16:58:20 +0000

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

What I Built
Every developer has the same quiet ritual: a command fails, you paste the error into a search engine, you land on a familiar answer, and you think I have definitely fixed this before. You did. You just don't remember where.
Terminal Déjà Vu is a local-first CLI tool that remembers for you. When a command fails, it searches your own past fixes and tells you: "You solved something like this on [date]. Here's what worked." If it has never seen the error, it falls back to a local model that explains the failure in plain language.
No cloud API. No account. Nothing leaves your machine.

Who It's For
Anyone who lives in a terminal and keeps rediscovering the same fixes: port already in use, npm dependency conflicts, git detached HEAD, permission denied, MongoDB connection refused. That is most of us, and especially students and juniors who haven't yet built up muscle memory.

Demo
The flow in about 30 seconds:

A command fails: node server.js throws EADDRINUSE.
I run dejavu why.
It answers: "You solved something like this on [date]: lsof -i :3000, then kill the process." It also adds one line adapting the fix to the current port.
A brand new error gets a clearly labeled "no past fix found" explanation from a local Gemma model.
After I fix it, dejavu save stores the fix, so next time it's instant. Code: [https://github.com/ShubhamHagawane/Terminal-D-j-Vu.git]

The Sloth Angle
The theme was building something that does the work so you don't have to, so I made the tool lazy in the right ways:
• You do nothing to capture data. A tiny shell hook records failures in the background, and the prompt never slows down.
• It indexes lazily. A "sloth mode" indexer embeds new items in small batches, sleeps between them, and backs off when the laptop is on battery or busy.
• It saves effort on repeat. Solve a problem once and you never really solve it again.

How I Built It
The design decisions that mattered most:

Normalize before embedding. Error messages are full of paths, ports, line numbers, and hashes. I strip those out first, so "same error, different project" still matches. This single step improved retrieval more than any model change.
Redact before storing. Shell history is full of tokens, passwords, and API keys. A redaction step masks likely secrets before anything touches disk, and it has its own tests.
Keep the model on a short leash. When a past fix is found, the prompt contains only that fix and the current error, and tells Gemma not to invent extra steps. The model adapts your answer; it doesn't replace it.
Degrade gracefully. If Ollama isn't running, the tool falls back to keyword search and says so, instead of failing. I built this in four parts (foundation, retrieval, the Gemma layer, then stats and polish) and tested each one before starting the next.

Why Open Innovation Matters Here
This project only makes sense with open models.
Privacy is the whole point. Your shell history contains hostnames, file paths, internal project names, and sometimes secrets you pasted by accident. A tool that sends that to a cloud API is a liability. Running Gemma and the embedding model locally means the data physically cannot leave your machine.
It works offline. I turned Wi-Fi off and ran the same demo. Nothing changed, because nothing was ever online. A closed API would have stopped working the moment I lost connection, which is exactly when I'm most likely to be debugging on a train or in a dorm with bad Wi-Fi.
It costs nothing to run. A tool that runs on every failed command would be expensive per call with a paid API. Locally, it's free forever, so I can run it as often as I like.
I can see inside it. Because the models and the code are open, I could inspect exactly what gets sent to the model and tighten the prompt. With a hosted model, that's a black box.

Prize Category
Best Use of Gemma: Gemma generates the plain-language explanations and adapts a saved fix to the current error, all running locally through Ollama. [CONFIRM WHICH GEMMA VARIANT YOU USED AND WHY.]
What I'd Build Next
• Mining shell history to suggest fixes automatically, by spotting a failed command followed by a successful variation
• PowerShell and fish support
• Sharing a fix library with a teammate through an opt-in, redacted export
Try It
git clone [https://github.com/ShubhamHagawane/Terminal-D-j-Vu.git]
cd terminal-deja-vu
npm install
ollama pull nomic-embed-text && ollama pull [gemma2:2b]
node demo/seed.js # optional: load sample fixes
dejavu init --shell zsh # follow the printed instructions
If it saves you from solving the same error twice, that's the whole job done. Thanks for reading, and happy Hacktoberfest!
Built for the Hacktoberfest Open-Source AI Challenge, Week 3: Slow and Steady.

PrivateDesk: Ask Your Office PDFs Anything, Answered Locally With Page Citations

Shubham Hagawane — Sat, 17 Oct 2026 19:04:17 +0000

What I Built

PrivateDesk is a local document Q&A app for small professional offices: accountants, clinics, and small law firms.

These offices sit on piles of PDFs (contracts, invoices, intake forms, policies) that they often cannot upload to a cloud AI tool because of client confidentiality. So they either skip AI completely or paste sensitive files into a service they don't control.

PrivateDesk fixes that. You drop in your PDFs, ask a question in plain language ("What are the termination terms in the Sharma contract?"), and get an answer with the exact file name and page number it came from. A language model, embeddings, and the database all run on the office's own computer. It works with the Wi-Fi turned off.

Who would pay: a three-person accounting or law office that wants AI help but can't risk client data leaving the building. The business model is simple: one-time setup plus support. I install it on their machine, load their documents, and handle updates. No per-seat subscription, no per-token bill, no vendor holding their data.

Demo

All documents in the demo are fake, with invented names and data.

[https://github.com/ShubhamHagawane/PrivateDesk]

How I Built It

Everything at runtime is open source and local:

Model: a small open-weight Gemma model running through Ollama (default gemma3:4b, configurable). It answers questions using only the excerpts retrieved from the user's documents.
Embeddings: nomic-embed-text, also served locally through Ollama, to turn document chunks and questions into vectors.
Ingestion: PDFs are parsed page by page with pdfjs-dist, then split into overlapping chunks within each page, so every chunk keeps an exact page number.
Storage and retrieval: chunks and embeddings are stored in MongoDB. For a small office's document set, cosine similarity over the stored vectors is fast enough, so I kept the architecture simple.
Answering: the top matching chunks go into a strict prompt: answer only from the excerpts, cite [file, page N] for every claim, and reply "I couldn't find that in the uploaded documents" when the answer isn't there. Tokens stream to the UI as they're generated.
App: Node/Express backend and a React (Vite) front end with an upload sidebar, a chat panel, and clickable source chips that show the retrieved excerpt.

The design choice that matters most: citations are not decoration. A wrong answer from a legal or clinical document is worse than no answer, so the app always shows where an answer came from and refuses to guess.

Limits right now (honest version): text-based PDFs only (no OCR for scans yet), and a small local model can miss nuance on long or complex clauses, which is why the source excerpt is always one click away.

Why Does Open Innovation Matter?

This product only works because the model is open.

Privacy is the product. The whole pitch is that files never leave the machine. With a closed API, that sentence would be false, and the customers I'm targeting couldn't legally or ethically use the tool.
Cost makes the business work. A hosted API charges per token, forever, and a document-heavy office would run up a bill every month. A local model has no per-query cost, so I can sell a one-time setup with support. 
No lock-in. The model is a setting (CHAT_MODEL), not a dependency on one vendor's pricing or policy changes. If a better open model appears, the office upgrades without rebuilding anything.
It works offline. In the demo, I turn Wi-Fi off and it still answers, which is something no closed API can do.

Prize Categories

Best Use of Gemma: the whole answering step runs on a locally served Gemma model through Ollama.
Best Use of Entire: I shared the agent sessions behind this project (link above).
Best Use of GitHub Copilot: [DESCRIBE HOW YOU USED IT, OR DELETE]
Best Use of a .tech Domain: [ADD YOUR .tech LINK, OR DELETE]
Best Use of MongoDB Atlas: [KEEP ONLY IF YOU ACTUALLY USED ATLAS OR ATLAS LOCAL, E.G. WITH VECTOR SEARCH. DELETE IF YOU USED PLAIN LOCAL MONGODB]
Best Use of Sentry Agent Tracing: [KEEP ONLY IF YOU ADD TRACES AND SCREENSHOTS, OR DELETE]

NatureQuest AI: Touch Grass with Local Gemma AI 🌿

Shubham Hagawane — Sun, 11 Oct 2026 11:17:12 +0000

I built NatureQuest AI, a web application that uses a locally running open-weight AI model to encourage people to spend more time outdoors and notice the natural world.

Users can choose an activity such as walking, birdwatching, gardening, cycling, or nature observation, select a duration and difficulty, and generate a personalized outdoor quest.

The application also provides a reflection prompt so users can record their experience after completing a quest.

Demo

The application runs locally on my computer.

Screenshots: Add real screenshots of:

The NatureQuest AI home page.

The quest creation form.

The local Gemma model running through Ollama.

Code

GitHub repository: https://github.com/ShubhamHagawane/NatureQuest-AI

The repository contains the React frontend, Express backend, local AI integration, and setup instructions.

How I Built It

I built the frontend using React, Vite, and CSS. The backend uses Node.js and Express to handle quest-generation requests.

For AI generation, I integrated Gemma 2 2B through Ollama, allowing the model to run locally rather than relying on a paid hosted inference API.

The workflow is:

The user chooses an activity, duration, and difficulty.

The React frontend sends the preferences to the Express API.

The backend sends a prompt to the local Gemma model through Ollama.

The response is validated and returned as a structured quest.

The user can complete the quest and save a reflection in browser storage.

I also included sample quests for situations where the local model is unavailable.

Why Does Open Innovation Matter?

Open innovation makes AI experimentation more accessible to students, independent developers, and communities that may not have access to expensive cloud infrastructure.

Using an open-weight model locally gave me an opportunity to learn how to integrate AI into a real application while keeping inference on my own computer after the model is downloaded.

NatureQuest AI explores a simple idea: AI doesn't always need to keep us staring at a screen. It can help us plan an activity that encourages us to step away from technology and experience the world around us.

My Agent Session

I used ChatGPT as a development assistant while building and debugging the application

Prize Categories

My project is submitted for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

The project combines a locally running open-weight AI model with an application designed to encourage outdoor activities and real-world engagement.

devchallenge #hf26challengease pick one member to publish the submission and credit teammates by listing their DEV usernames directly in the body of the post. -->

NatureQuest AI: Touch Grass with Local Gemma AI 🌿

Shubham Hagawane — Sun, 11 Oct 2026 10:57:36 +0000

The idea

We spend a lot of time looking at screens, even when there are interesting things to discover outside. I wanted to build something that encourages people to take a break from their screens and explore the natural world.

That's why I built NatureQuest AI, an AI-powered outdoor adventure companion that generates personalized nature quests based on a user's activity, available time, and difficulty level.

This project is my contribution to the Hacktoberfest 2026 Open-Source AI Challenge — Week 1: Touch Grass.

What can NatureQuest AI do?

Users can choose activities such as:

🚶 Walking

🚲 Cycling

🌱 Gardening

🐦 Birdwatching

🔎 Nature observation

The application generates a short outdoor quest with instructions, a time limit, a difficulty level, and a reflection prompt. Users can then go outside, complete the quest, and record their experience.

The goal is simple: make the screen the starting point for an outdoor experience, not the destination.

How I built it

The project uses the following technologies:

React + Vite: Frontend interface

Tailwind CSS: Styling

Node.js + Express: Backend API

Ollama: Local model runtime

Gemma 2 2B: Open-weight language model

Browser local storage: Saving quest history locally

Why local AI?

I initially explored hosted inference through Hugging Face Inference Providers, but I ran out of available inference credits.

Instead of stopping there, I switched to running Gemma locally through Ollama.

This gave the project several advantages:

Quest generation does not require paid Hugging Face inference credits.

Once the model is downloaded, generation can work without an internet connection.

User prompts can be processed locally rather than sent to a hosted inference service.

I can experiment with the model and change the AI integration as the project evolves.

Local inference still requires a capable device, sufficient memory, and Ollama running. The initial model download also requires an internet connection.

How it works

A user chooses an outdoor activity and preferences.

The React frontend sends the request to the Express backend.

The backend sends the prompt to the locally running Gemma model through Ollama.

Gemma generates a structured nature quest.

The application displays the quest so the user can head outside and complete it.

Screenshots and demo

Homepage

[

]

AI-generated quest

[

]

Local model running

[

]

What I learned

This project helped me understand how to connect an open-weight language model to a full-stack web application.

I also learned that AI integration isn't only about sending a prompt. The application needs structured responses, validation, error handling, and a fallback experience when generation fails.

Most importantly, I learned that switching from a hosted model API to local inference can make a project more independent of external inference credits.

What's next?

I'd like to improve NatureQuest AI with better outdoor activity recommendations, richer quest history, and additional ways to document discoveries while keeping the experience focused on spending time outside.

Try the project

GitHub repository: [https://github.com/ShubhamHagawane/NatureQuest-AI]

If you try NatureQuest AI, I'd love to hear which outdoor quest you completed!