DEV Community: Shashwat Sinha

Constraint Kitchen: A Local LLM That Says No

Shashwat Sinha — Mon, 19 Oct 2026 05:43:04 +0000

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

What I Built

Constraint Kitchen turns the junk in your cupboard into something worth building.

Type what you have — cardboard, string, tape, old notebooks — plus your time, budget, skill level and any restrictions (no sharp tools, no glue). A local Gemma 3 1B hands back three genuinely different DIY ideas that respect all of it. Pick one, get a numbered build guide. Changed your mind? Remix it four ways: zero-buy, use-it-up, remove a material, or simplify for a beginner.

Most idea lists assume a trip to the shop. This one starts where you already are.

Who pays: nobody. It runs on your own machine — no account, no API key, no usage meter. It's for makers starting a craft side hustle, teachers who need free classroom projects, and anyone who just bought a storage bin they don't want.

The hard part isn't making ideas. It's not lying about them. Show me "cut the cardboard" after I said no sharp tools and you've failed me, JSON-valid or not. So it refuses more often than it succeeds — and says exactly why.

Demo

⚠️ There's no deployed link, on purpose. It needs a local Ollama service and binds to 127.0.0.1 only. No hosted instance exists because there shouldn't be one.

→ github.com/ShashwatSinha03/HF_ConstrainKitchen — clone, four minutes, running.

1. Cardboard Box Garden        2. Paper Chain Support      3. String Bookmark
 Uses: cardboard, tape           Uses: paper, tape            Uses: notebook pages, string
   20 min · easy                  20 min · easy                20 min · easy

   [ Build This → ]  [ Zero-buy ]  [ Use-it-up ]  [ Remove a material ]  [ Simplify it ]

Measured on my Mac (M3, 8 GB, gemma3:1b): three ideas in ~10–20s, a guide in ~7–15s, a remix in ~3–8s. The model is nondeterministic — the same diagnostic scored 5/7 and 6/7 on identical code. And guides under no sharp tools land about 2 in 6. The gate refuses, on purpose.

Code

→ github.com/ShashwatSinha03/HF_ConstrainKitchen (MIT)

Two ideas did the heavy lifting:

Output is untrusted input. A 1B model will invent a glue gun you don't own. So Python checks, and the meaning is directional:

def _covered_by_inventory(item, inventory):
    """One shared word is NOT evidence — "cardboard" says nothing
    about "glue gun", and a substring isn't a match either."""
    return _significant(item) <= inventory

A deadline you can trust. requests' timeout isn't a total deadline — I measured 420s with timeout=120 never firing. So it streams and checks the wall clock per chunk. Forced timeout returns in 0.07s, zero leaked threads.

233 mocked tests, green on 3.10 / 3.12 / 3.14 in CI — with no Ollama present, which is what makes that evidence instead of decoration.

How I Built It

gemma3:1b via Ollama. Python + Streamlit + requests. Two dependencies. No LangChain, no vector DB, no agents, no cloud.

The 1B shaped everything. It gets grammar-constrained decoding, not prompt-begging — the schema does the work. It gets a prompt showing three objects, because a 1B copies the shape it can see, and my original template showed one, so the model faithfully returned one, every single time. And the invariants live in the schema itself: minItems: 1 on materials, maxItems: 0 on purchases at ₹0.

Six sprints. Honest version: the model was the hard part, the validation was the work — and three sprints in, the pipeline looked finished and failed every real request. I only found out because I finally pointed a real model at it. Four sprints of very confident documentation, none of it observed.

Why Does Open Innovation Matter?

Because the refusal model is the product, and a closed API can't support it honestly.

An app whose promise is "don't recommend what I can't build" is an app whose credibility lives in what it admits it doesn't know. No key means no floor on cost. No rate limit means no floor on latency. Lose signal and the feature is simply gone. This one works on a plane, costs nothing per idea, and needs no account.

Owning the stack also bought me permission to be honest. My README's first section is Known limitations: no sharp tools fails two times in three, the model is nondeterministic, nothing above ₹0 is price-verified, and nothing checks whether a project is actually buildable.

A closed API rewards a smooth happy-path demo. I'd rather ship something that fails loudly and tells you exactly why.

WalkQuest: The AI That Ghosts You (So You Can Touch Grass) 🌿

Shashwat Sinha — Wed, 07 Oct 2026 11:25:09 +0000

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

WalkQuest 🌿

What I Built

An AI that creates a reason to go outside — then shuts up and gets out of your way.

WalkQuest is a local-first micro-app that uses a tiny open-weight model (Gemma 3 1B) to generate a personalized outdoor quest based on how much time you have, your mood, and where you're headed. You read the quest. You click "START WALK." The app explicitly tells you to put your phone away. You go outside. You come back. You optionally jot down one thing you noticed. Done.

No GPS. No maps. No step counting. No streaks. No notifications. No cloud. No account. No data leaves your machine.

Who is it for?

People who want a nudge to touch grass but don't want another app demanding their attention. The chronically online. The "I should go for a walk but I'm doomscrolling" crowd. Anyone who appreciates that the best technology is the kind you forget exists.

Demo

No deployed link. That's the point.

WalkQuest runs entirely on your laptop. Here's the 30-second demo flow:

┌─────────────────────────────────────────────────────────────┐
│  WALKQUEST 🌿                                               │
│  A tiny AI-generated reason to go outside.                  │
├─────────────────────────────────────────────────────────────┤
│  How much time?    [15 min] [30 min] [60 min]               │
│  What's your mood? [Relaxed] [Bored] [Stressed] [Energetic] │
│  Where?            [Park] [Campus] [Neighborhood] [Anywhere]│
│                                                             │
│  [ Generate My Quest ]           ← One local LLM call       │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│  🌿 YOUR QUEST: "The Crack in the Sidewalk"                 │
│  30 minutes                                                 │
│  1. Find three different textures underfoot.                │
│  2. Walk a block you usually skip.                          │
│  3. Stand still for 60 seconds. Just listen.                │
│  4. Spot something growing where it "shouldn't."            │
│  FINISH: What made you smile?                               │
│                                                             │
│  [ 🌿 START WALK ]                                          │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│                    🌱 GO.                                   │
│                                                             │
│         Your quest is waiting for you.                      │
│         Put your phone away.                                │
│         Go outside.                                         │
│                                                             │
│         See you when you get back.                          │
│                                                             │
│                    [ I'M BACK 🌿 ]                          │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│  🌿 WELCOME BACK                                            │
│  You went outside. That's the point.                        │
│  How did it feel?  [GREAT] [GOOD] [MEH]                     │
│  What did you notice? [________________________]            │
│  [ FINISH QUEST ]                                           │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│  🌱 NICE.                                                   │
│  You noticed: "the moss between sidewalk cracks"            │
│  That's enough. You went outside.                           │
│                                                             │
│  [ New Quest ]                                              │
└─────────────────────────────────────────────────────────────┘

Try it yourself:

ollama pull gemma3:1b
ollama serve
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
streamlit run app.py

Code

GitHub: https://github.com/ShashwatSinha03/HF_TouchGrass

WalkQuest/
├── app.py          # Streamlit UI + walk lifecycle (350 lines)
├── llm.py          # Ollama client + prompt engineering (120 lines)
├── requirements.txt# streamlit, requests (that's it)
├── README.md       # Full docs + architecture + offline demo
└── .gitignore

Architecture:

┌──────────────┐     HTTP/JSON      ┌──────────────┐
│  Streamlit   │ ─────────────────▶ │   Ollama     │
│    (UI)      │ ◀───────────────── │  (localhost) │
└──────────────┘   Gemma 3 1B       └──────────────┘
       │                                  │
       ▼                                  ▼
  Session State                     Local Model
  (no database)                   (800MB, 1B params)

How I Built It

The stack is intentionally boring:

Gemma 3 1B (open-weight, 800MB, runs on CPU/MPS)
Ollama for local model serving
Streamlit for the UI (zero frontend fuss)
requests for the HTTP call
Python + session_state for everything else

No frameworks. No LangChain. No vector DB. No RAG. No agents.

Just one carefully crafted prompt → one HTTP POST → one structured response.

The prompt engineering is where the magic lives:

7 challenge categories (Observation, Movement, Exploration, Mindfulness, Play, Creativity, Optional Social)
Mood-aware energy tuning (Stressed → calming, Bored → playful, Energetic → movement)
Environment-specific guidance (Park vs Campus vs Neighborhood vs Anywhere)
Time-aware scoping (15min = 3 simple things, 60min = richer variety)
Anti-repetition via last-5-quest-titles context
Explicit safety + screen-free constraints

The UX philosophy:

Every screen after "START WALK" is designed to be unengaging. The "Walk Started" screen has one button: "I'M BACK." No timer. No map. No progress bar. The app wants you to close it.

Why Does Open Innovation Matter?

Because closed APIs would have ruined this.

Closed API Approach	WalkQuest (Open Weight + Local)
$0.002/call × 1000 users × daily = $$$	$0 forever
Requires internet, API key, account	Works on a plane, in a cabin, offline
Your mood + location + habits logged	Your data never leaves your machine
Model updates break your prompts	You own the model file
Rate limits, quotas, TOS changes	`ollama pull` and you're current
"We'll use your data to improve"	"We don't even have a server"

Open-weight models made this possible because:

Privacy by architecture, not policy — There's no server to leak from.
Zero marginal cost — The 500th quest costs the same as the 1st: electricity.
Hackability — Want a different model? Swap gemma3:1b for llama3.2:1b in one line. Want to fine-tune on "better quests"? The weights are yours.
No gatekeepers — No approval process, no waitlist, no "enterprise plan" for local inference.

The irony: We used AI to build something that reduces screen time. That only works if the AI lives on the user's device, not in a data center optimizing for engagement. Open weights let the incentive structure align with the human.

The Philosophy, In One Line

AI generates something useful. You read it. Screen goes away. Real life begins.

If you spend less time in WalkQuest, the product is working.

StudyLens for my tensed sister juggling with her academics

Shashwat Sinha — Sun, 04 Oct 2026 06:29:54 +0000

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

StudyLens — A Local-First AI Study Assistant

Built for: My younger sister, who's drowning in lecture PDFs and needs a study tool that works offline, respects her privacy, and doesn't require a $20/month subscription.

What I Built

StudyLens turns passive reading into active learning — completely on your machine. No API keys, no cloud, no accounts, no telemetry.

Upload a PDF/TXT → Get:

🧠 Understand — Ask questions, get grounded answers with citations from your material
📚 Revise — One-click structured revision sheet (concepts, key terms, relationships, "remember" facts, common confusions)
🎯 Quiz — 5 or 10 mixed MCQ/short-answer questions, auto-scored with weak-area identification
⏱️ Exam Mode — "I have 30 minutes" → prioritized study plan (Must Know / Good to Know / Skim) with time estimates

Demo

ollama pull gemma3:1b
ollama serve
pip install -r requirements.txt
streamlit run app.py

Opens at http://localhost:8501 — works on any machine that runs Python + Ollama (tested on macOS, Linux, Windows).

Code

github.com/ShashwatSinha03/HF_BuildForAFriend

study-lens/
├── app.py          # Streamlit UI + orchestration
├── llm.py          # Ollama client + prompts + robust JSON parsing
├── document.py     # PDF/TXT extraction + keyword retrieval
├── requirements.txt
└── README.md

How I Built It

Stack: Python • Streamlit • Ollama • Gemma 3 1B • PyPDF • Requests

Architecture decisions that matter:

Constraint	Solution
No cloud/API keys	Local Ollama + Gemma 3 1B (815MB)
Small model, unreliable JSON	Multi-strategy parser (standard → trailing-comma fix → duplicate-key removal → regex fallback)
No embeddings/vector DB	Lightweight keyword-overlap retrieval (TF-IDF-inspired, ~30% of doc sent to LLM)
Limited compute	Single LLM call per action; batch short-answer eval; conservative token limits
Privacy-first	Zero network calls except localhost:11434; session-only state

Sprint-based development (6 sprints over 3 days):

Foundation — upload, extraction, session state, Ollama health checks
Explain — grounded Q&A with retrieval
Revise — structured revision sheets
Quiz — MCQ + short answer, batch evaluation, weak areas
Exam Mode — time-bounded prioritization
Polish — robust parsing, error UX, README, .gitignore

Why Open Innovation Matters

This project exists because of open weights and local inference.

If I'd used a closed API:

❌ Cost — $20/month per user minimum
❌ Privacy — lecture notes sent to third parties
❌ Offline — no studying on planes, in libraries, or with spotty campus WiFi
❌ Customization — can't tweak prompts, retrieval, or model behavior
❌ Longevity — API deprecation, price hikes, or service shutdown kills the tool

With Gemma 3 1B + Ollama:

✅ Free forever — runs on hardware she already owns
✅ Private — her notes never leave her machine
✅ Offline-first — works anywhere
✅ Hackable — every prompt, retrieval strategy, and UI decision is in plain Python
✅ Sustainable — no vendor lock-in; model runs as long as Python runs

The "small model" constraints forced better engineering: lightweight retrieval, strict prompting, defensive parsing, batch evaluation. Those are better patterns that scale up — not compromises.

The Friend Test

"Wait, it's actually free? And my PDFs don't get uploaded anywhere? Damn, broski"

Yep, that's my sister, after using it for her midterms prep

That's the whole point. Open innovation doesn't just lower barriers — it changes what's possible to build for the people you care about.