DEV Community: Trideep Chakraborty

StudyDebt: Rewarding Academic Laziness with Open-Source AI and 10-Minute Micro-Sessions

Trideep Chakraborty — Sat, 24 Oct 2026 01:38:52 +0000

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

What I Built:
Every student and self-taught developer suffers from the same bad habit: hoarding hundreds of messy screenshots of lecture slides, textbook diagrams, code snippets, and whiteboard formulas with the vague promise of "I'll study this later."

Over time, this backlog morphs into crushing "study debt"—an overwhelming pile of visual clutter that induces guilt, decision paralysis, and procrastination. Facing a 4-hour marathon cramming session feels exhausting, so we do nothing.

StudyDebt is a liquid-glass study recovery web application designed in the true spirit of International Sloth Day: it rewards your laziness by turning academic chaos into steady, low-effort micro-wins.

Instead of demanding hours of tedious note-taking, StudyDebt automates the friction:

"Have 10 Minutes?": You don't have to organize anything. Drag and drop your raw screenshots, and open-weight models distill them into a plain-English gist, core concepts, and a 10-minute micro-lesson with an interactive knowledge check.
"Your Next Small Win": Eliminates decision fatigue entirely. You never have to figure out what to study; a recommendation engine analyzes your energy level (Low, Medium, High) and available time (5m, 10m, 15m, 25m) to serve up the single smallest, highest-leverage task.
"Rebalance My Week": Took a 3-hour sloth nap or skipped your Tuesday study goal? StudyDebt never shames you or breaks your schedule. One click redistributes your pending tasks across the remaining days without punishing you or destroying completed work.
Demo

🌐 Live Web Application: https://trideep091.github.io/studydebt/
💻 Open-Source Repository: https://github.com/Trideep091/studydebt

Key User Flows in Action:
The Sloth Dashboard: Deep midnight navy aesthetic (#080B18) with frosted glass depth (backdrop-filter: blur(20px)), real-time study debt hour counter, and immediate 10-minute sprint recommendations.
Screenshot Vault: Drop study slides in PNG, JPG, or WebP format. Open-weight vision & OCR pipelines extract equations and definitions into structured flashcard overviews.
Adaptive Focus Mode: Distraction-free countdown timer, interactive mid-session checkpoint questions, and confidence ratings that feed directly into a Leitner-style spaced repetition queue.
Natural Language Weekly Planner: Type "I need to review Java memory allocation, finish linear algebra, and practice 2 SQL queries before Friday", and the AI balances the workload across your daily capacity meters.
Code
You can find the full source code on GitHub:

Trideep091 / studydebt

this is a website for students

StudyDebt — Your backlog, under control.

Small sessions. Steady progress. Less academic chaos.

StudyDebt is a creative, premium, liquid-glass-themed study recovery application designed to rescue students from academic chaos. It transforms forgotten piles of educational screenshots, lecture slides, and unstructured to-do lists into manageable, bite-sized study sessions and deadline-aware weekly plans.

🌟 Key Features

1. Liquid Glass Aesthetic

Deep midnight navy palette (#080B18) and frosted glass surfaces with refined background depth.
backdrop-filter: blur(20px) with saturation boosts, translucent glowing borders, and realistic reflective highlights.
Distraction-free, accessible contrast adhering to WCAG and prefers-reduced-motion.

2. Backlog Manager & "Your Next Small Win"

Topic organization with subjects, effort estimates in minutes, priorities (Low, Medium, High, Urgent), and deadlines.
Your Next Small Win: A deterministic recommendation algorithm that factors in urgency, available time slots (5m, 10m, 15m, 25m), and concept mastery to suggest the exact next step without cognitive overload.

3.

…

View on GitHub

Project Architecture:
studydebt/
├── src/ # React 19 + TypeScript + Vite Frontend
│ ├── components/ # Liquid-glass UI components (Dashboard, Vault, Planner)
│ ├── services/
│ │ ├── ai/client.ts # Open-weight inference client & offline fallback engine
│ │ ├── db/indexedDb.ts # Local-first persistence via IndexedDB (idb)
│ │ └── scheduler/ # Spaced repetition, recommendation & rebalancing engines
│ └── types/index.ts # Strictly typed domain schemas
├── backend/ # FastAPI Microservice
│ ├── app/
│ │ ├── api/routes/ # AI & OCR endpoints (/summarize-screenshot, /plan-week)
│ │ └── services/ # Prompt templates & Ollama/vLLM integration
│ └── tests/test_api.py # 100% automated test coverage with pytest
├── public/ # Static assets (.nojekyll, 404.html SPA fallback)
├── .github/workflows/deploy.yml# Automated GitHub Actions deployment pipeline
└── docker-compose.yml # Containerized local development stack
How I Built It
StudyDebt is built around an open-weight, local-first AI stack:

Open-Weight AI Inference:
Primary local runner: Meta Llama 3.2 (3B) and Gemma 2 (9B) served via Ollama on local hardware (http://localhost:11434).
Production runner: Decoupled FastAPI ASGI microservice with Pydantic structured output validation, compatible with self-hosted vLLM and open-weight inference providers (e.g. Together AI, Groq Llama 3.3).
Local-First Privacy Architecture:
Built with IndexedDB (idb) for offline-first client storage. All student notes, screenshots, study logs, and spaced repetition intervals persist privately in the user's browser.
The frontend includes a built-in client-side fallback engine that generates deterministic schedules and educational heuristics even when completely disconnected from the network.
Frontend Craftsmanship:
React 19, TypeScript, and Vite 8 with zero heavyweight UI library dependencies.
Hand-crafted liquid-glass styling using pure modern CSS (subtle radial gradients, specular highlights, and high-contrast accessible typography via Google Fonts' Outfit and Plus Jakarta Sans).
DevOps & Continuous Deployment:
Automated GitHub Actions pipeline (.github/workflows/deploy.yml) deploying directly to GitHub Pages with least-privilege OIDC tokens, SPA 404 redirects, and Jekyll bypasses.
Why Does Open Innovation Matter?
Open innovation and open-weight models are not just nice-to-haves for StudyDebt—they are the entire reason the project is viable:

Academic Privacy & Data Sovereignty: Students frequently screenshot unreleased lecture slides, proprietary university problem sets, grading rubrics, and handwritten study notes. Uploading private classroom materials to closed, commercial AI APIs risks training leakage and violates academic privacy policies. With open-weight models (Llama 3.2 / Gemma 2) running locally through Ollama, zero bytes of private course material ever leave the student's laptop.
Ending the "Student Tax": Closed proprietary APIs charge per-token fees or require $20/month subscriptions that students cannot justify for organizing disorganized notes. Open-weight models running on consumer hardware (Mac Apple Silicon or standard GPUs) make intelligent study recovery 100% free forever.
True Offline Resilience: Studying happens in library basements with no cell reception, on trains, and during campus Wi-Fi outages. Because open models and IndexedDB run locally, StudyDebt works with zero internet connection, guaranteeing zero vendor lock-in.
My Agent Session
This project was built and debugged in pair programming collaboration with Antigravity (powered by Gemini 3.8 Flash).

The agent helped inspect the repository, implement the spaced repetition scheduling heuristics, configure the decoupled API client with offline graceful degradation, build the GitHub Actions Pages deployment pipeline, and configure the subpath asset resolution.

You can inspect the agent session transcript preserved via DevRelay:

Building NoBugs AI: AI-Powered Log Investigation Platform

You

Build NoBugs AI — an AI-powered log investigation and root-cause analysis platform that ingests logs, redacts secrets, classifies incidents, visualizes error timelines, and suggests fixes.

Agent

I am building the full-stack NoBugs AI platform with a FastAPI backend, React + Vite frontend, local open-weight AI inference (Ollama / Llama 3.2), and a regex redaction pipeline.

▸ build_nobugs_ai Initialize project structure, backend models, pipeline, and frontend dashboard

Input

Initialize project structure, backend models, pipeline, and frontend dashboard

Output

Created FastAPI application, ingestion pipeline, incident models, timeline analyzer, and React dashboard.

You

Connect the frontend upload and explorer directly so that log analysis works offline and in production with dynamic graphs and root-cause suggestions.

Agent

Updated IngestionView and LogExplorerView to route through the resilient API service with local client-side log processing and incident classification fallback. Deployed live to Vercel.

▸ deploy_production npm run build && vercel --prod

Input

npm run build && vercel --prod

Output

Build succeeded in 179ms. Production deployed at https://nobug091ai.vercel.app

The Lazy Payoff
Here is the cold, hard math on how much effort StudyDebt saves:

Tidying & Filing Time: Manually sorting 30 screenshots into folders, typing out summaries, and writing flashcards usually takes 45 to 60 minutes of tedious manual labor. With StudyDebt, dragging the screenshots into the vault takes 5 seconds, and open-weight models instantly distill the formulas and key takeaways.
Decision Paralysis: Students spend an average of 15 to 20 minutes every evening staring at their notes trying to decide what to study first. "Your Next Small Win" computes the ideal 10-minute task in under 300 milliseconds.
Guilt-Free Sloth Mode: When you skip a study day, traditional calendar apps leave you with an intimidating wall of overdue red notifications. Clicking "Rebalance My Week" calculates daily capacity ceilings and re-allocates pending tasks in 1 click, saving you from ever having to rewrite a planner.

NoBugs AI: Turning Application Logs into Actionable Debugging Insights

Trideep Chakraborty — Wed, 14 Oct 2026 07:05:42 +0000

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

What I Built

NoBugs AI is an AI-powered log investigation tool designed to help developers understand application failures without manually searching through thousands of log lines.

Debugging can be time-consuming. A single application failure can produce hundreds of related errors, making it difficult to identify the underlying problem and determine what to investigate next.

NoBugs AI aims to transform raw application logs into structured, evidence-backed incident reports using open-weight AI.

Key Features

Flexible log input: Drag and drop log files or paste log content directly.
Automatic error detection: Identify exceptions, failures, warnings, and suspicious events.
Error correlation: Group potentially related errors to help uncover common causes.
Severity classification: Organize incidents into Critical, High, and Mild categories.
AI-powered diagnosis: Generate context-specific root-cause hypotheses and debugging recommendations for individual incidents.
Incident timeline: Explore how errors evolve over the available three-to-four-hour log history.
Privacy protection: Redact sensitive information, including API keys and access tokens, before AI analysis.
Excel reporting: Export incident summaries, supporting log events, severity, status, and recommended fixes.

The goal is to go beyond displaying errors and help developers understand what happened, why it might have happened, and what they should investigate next.

Who Would Pay for It?

NoBugs AI is intended for independent developers, freelancers, startups, and small software engineering teams that need practical debugging assistance without investing in expensive enterprise observability solutions.

By reducing the time spent manually investigating logs, the product aims to make debugging more efficient and accessible.

Demo

Live Demo: https://trideep091.github.io/nobugsai/

The planned demonstration follows a simple workflow: upload a log file, detect and correlate errors, inspect AI-generated diagnoses, explore the incident timeline, and export a structured report.

Code

GitHub Repository: https://github.com/Trideep091/nobugsai

The project is being developed as a modular application with separate components for log ingestion, parsing, incident analysis, AI integration, privacy protection, and reporting.

How I Built It

The core idea behind NoBugs AI is to make open-weight AI an essential part of the debugging workflow rather than simply adding a chatbot to a log viewer.

The planned architecture separates deterministic log processing from AI-powered reasoning.

AI at the Core

The open-weight model is intended to handle tasks that require understanding technical context, including:

Interpreting complex error messages and stack traces.
Identifying possible relationships between failures.
Distinguishing symptoms from potential root causes.
Generating incident-specific debugging recommendations.
Explaining uncertainty and identifying missing evidence.
Summarizing how an incident evolved over time.

For example, when a database timeout is followed by repeated API failures, the system should investigate whether the events are related rather than treating every error as an independent problem.

Every diagnosis should be grounded in actual log evidence, and uncertain conclusions should be clearly identified as hypotheses.

Technology Stack

The planned stack includes:

React and TypeScript for the user interface.
Python and FastAPI for the backend.
Ollama for running a compatible open-weight model locally.
Structured log-processing logic for parsing timestamps, stack traces, and events.
OpenPyXL for Excel report generation.

Open-weight model: [Add the exact model name and version once integrated.]

The intention is to use deterministic code for tasks such as parsing, secret redaction, and report generation, while reserving AI for contextual interpretation, incident correlation, and remediation recommendations.

Why Does Open Innovation Matter?

Open innovation matters because debugging tools often process sensitive information about an application's internal behavior.

Logs can contain infrastructure details, request information, and accidentally exposed credentials. Local inference with a suitable open-weight model can help developers analyze this information without automatically sending it to a proprietary cloud AI service.

Open-weight models also give developers the freedom to experiment with different models, evaluate their performance on real debugging scenarios, and adapt the system to their needs.

For a student project, this creates an opportunity to explore how open AI can power a practical developer tool without making a closed API the only route to intelligent analysis.

The objective is to build something useful, transparent, and accessible to developers and small teams.

What's Next?

The next steps are to improve error correlation, evaluate the accuracy of AI-generated root-cause hypotheses, refine the incident timeline, and test the application against realistic log files.

I also want to gather feedback from developers to understand whether the tool can meaningfully reduce the time required to investigate application failures.

The long-term vision: Make debugging less about searching through thousands of log lines and more about understanding problems and finding evidence-backed solutions.

Hacktoberfest #OpenSource #AI #DeveloperTools

TouchQuest 🌿: The AI Photography Game That Tells You to Put Your Phone Away

Trideep Chakraborty — Tue, 06 Oct 2026 15:09:39 +0000

💡 What I Built
Modern apps are engineered as dopamine traps: infinite algorithmic feeds, push notifications, and glowing rectangles keeping us indoors.

I built TouchQuest — an AI-powered outdoor photography web game created specifically around the theme “Touch Grass.”

TouchQuest turns the traditional screen-time paradigm on its head: the screen is designed to be the shortest part of your experience.

text
┌────────────────────────────────────────────────────────┐
│ THE TOUCHQUEST LOOP │
│ │
│ 🤖 Read AI Mission ───> 🚶 Put Phone Down & Step Out │
│ │ │
│ ⚡ Earn XP & Badges <─── 📸 Return & Verify with AI │
└────────────────────────────────────────────────────────┘
🎮 The Core Game Mechanics
TouchQuest does not ask players to fiddle with time limits or settings. The game sets the rules automatically across exactly 3 levels and 9 real-world discoveries:

🟢 Level 1 — Explorer (Easy):

40 minutes • 4 photo challenges
“Start by noticing what is already around you.”
Broad awareness: vibrant natural greens, circular geometry, organic blooms, weathered textures.
🟡 Level 2 — Observer (Medium):

30 minutes • 3 photo challenges
“The easy discoveries are behind you. Now look closer.”
Restrictions & relationships: natural red that is strictly non-manmade, cast shadow silhouettes, echoing shapes of differing scales.
🔴 Level 3 — Creative Explorer (Hard):

15 minutes • 2 photo challenges
“Two photos. Make them count.”
Compositional twists: pareidolia (everyday objects that look like faces), nature & artificial elements interacting in one frame.
The Golden Curve:
Photos ↓ (4 → 3 → 2) while Difficulty ↑ (Easy → Medium → Hard)

✨ Features That Make It Special
⏱️ Beat-the-Clock "Done" Button: Completed your photos early? TouchQuest never forces you to wait. Once all photos in a round are verified, an active "Done" button lets you bank your speed bonus and advance immediately to the next round.
🚨 Emergency Level 3 Extension: If the 15-minute clock expires before completing both hard challenges, players get a one-time +3 Minute Emergency Extension (03:00 countdown).
🏡 Everyday Accessibility: Challenges never ask for remote mountains, waterfalls, or 10 km travel. Every quest is safely achievable in an ordinary neighborhood, university campus, sidewalk, or city park.
🧠 Anti-Repetition & Concept Memory Engine: The game remembers every concept you've ever completed. Replaying never yields recycled challenges or cheap synonyms; broad themes only return after a cooldown with an upgraded twist constraint (e.g. “Find two different shades of green in one frame”).
🏅 6 Collectible Embroidered Patches: Earn permanent game badges including First Explorer, Sharp Eyes, Nature Lover, Visual Hunter, Challenge Master, and Touch Grass Legend.
📸 Field Journal & Photo Archive: Review all past verified discoveries with AI vision commentary and time-saved metrics.
🎥 Demo
Live Demo URL: https://trideep091.github.io/touch-quest/

Demo Video / Walkthrough:

Interactive preview features:

Live WebRTC camera viewfinder with real-time shutter simulation.
In-browser AI vision scanner with laser line feedback.
Tactile Web Audio synthesizer (zero external sound files needed).
Procedural canvas particle confetti celebration.
💻 Code
https://trideep091.github.io/touch-quest/

Built with zero framework bloat: pure semantic HTML5, modern Vanilla CSS design system, modular ES JavaScript, and a zero-dependency local Node server.

🛠️ How I Built It
TouchQuest is built from the ground up around Open-Weight AI models rather than closed black-box APIs.

text
┌────────────────────────────────────────────────────────────────────────┐
│ TOUCHQUEST OPEN AI STACK │
├──────────────────────────────┬─────────────────────────────────────────┤
│ AI 1: Quest Generator │ AI 2: Vision Verifier │
│ (Qwen-2.5 / Llama-3.1) │ (PaliGemma-3B / Qwen-2.5-VL) │
├──────────────────────────────┼─────────────────────────────────────────┤
│ • Structured JSON generation │ • In-browser Canvas Pixel Diagnostics │
│ • History-aware memory bank │ • Excess Green (ExG = 2*G - R - B) │
│ • Public-space safety filter │ • Dynamic range & shadow penumbra │
│ • Category diversity balance │ • Radial symmetry & pareidolia checks │
│ • Smart variation engine │ • Constructive Pass / Fail commentary │
└──────────────────────────────┴─────────────────────────────────────────┘

Challenge Generation (Open-Weight LLMs) Employs open-weight architectures (Qwen-2.5-7B-Instruct and Llama-3.1-8B-Instruct). Uses strict system prompt formatting to return machine-validated JSON across 12 balanced outdoor categories (Flora, Geometry, Shadows, Reflections, Textures, Contrast, Pareidolia). A built-in history ledger audits past concept vectors to guarantee that consecutive quests are distinct.
Vision Verification (Edge & Open-Weight VLMs) Designed for hybrid execution using compact open vision-language models like PaliGemma-3B and Qwen-2.5-VL. Uses an off-screen HTML5 Canvas inspection layer to calculate: Excess Green Vegetation Index ($ExG = 2G - R - B$) to confirm living chlorophyll. Luminance threshold histograms to verify cast sunlight shadows. Circularity and edge complexity to validate geometric subjects. Delivers encouraging, natural language feedback: ✓ Challenge Complete: “Nice find! The vision model clearly detects vivid natural green tones in this outdoor composition.” ✕ Not Quite: “This photograph appears predominantly monochrome. Try framing your circular pebble closer to the lens.”
Tactile Audio & Visual Polish Built-in Web Audio API synthesizer generates mechanical camera shutter clicks, victory fanfares, and timer warning ticks on the fly without downloading external audio files. Single-folder portable architecture with persistent localStorage and memory fallbacks. 🌍 Why Does Open Innovation Matter? Outdoor photography and personal exploration are inherently intimate. Building TouchQuest with open-weight AI unlocks three advantages that closed proprietary APIs could never match:

🔒 Real Privacy for Real-World Photos: When players photograph their backyards, local neighborhood corners, or campus parks, those personal photos shouldn't be uploaded to proprietary cloud platforms to train closed commercial models. Open-weight vision models can run locally on-device (via WebGPU or edge runtimes like vLLM/Ollama), keeping private images on the player's device.

🔀 Zero Vendor Lock-In & Perpetual Availability: Proprietary APIs frequently deprecate endpoints, enforce unpredictable rate limits, or change pricing tiers overnight. With open-weight foundations (Qwen, Gemma, Llama, PaliGemma), TouchQuest belongs to the community and can be hosted anywhere forever.

🌿 Local Fine-Tuning for Bioregional Diversity: Every ecosystem is different. Open-weight models allow community contributors to fine-tune challenge generators on regional botany, urban architecture, or seasonal flora (e.g. Nordic winters vs. tropical rainforests) — an openness impossible behind closed API walls.

🤖 My Agent Session
This project was pair-programmed with Antigravity, an agentic coding assistant by Google DeepMind.

Autonomous Tooling Used: run_command for server orchestration, generate_image for bespoke embroidered badge assets and editorial hero artwork, and file modification tools.
Architecture Decisions: Designed a zero-dependency flat layout with vanilla ES modules, eliminating heavy build steps to ensure immediate accessibility on desktop and mobile browsers alike.
🏆 Prize Categories
Primary: Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass
Tags: #opensource, #ai, #webdev, #hacktoberfest

"Bro, I'm Bored": How I Built an Open-Source AI Free-Time Planner for My Roommate

Trideep Chakraborty — Sat, 03 Oct 2026 12:25:31 +0000

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

NOWWHAT? — You Have Free Time. We Have Ideas.

An AI-powered personalized free-time planner built on open-source AI to cure decision paralysis and turn unstructured hours into meaningful adventures.

What I Built

I built NOWWHAT? for my friend and roommate, who constantly finds himself stuck in our hostel room on weekends and between lectures. Whenever he has a stretch of free time, he ends up overwhelmed by choice, pacing the room or asking:

"Bro, I'm bored out of my mind. I've got 3 hours and ₹150, but I don't want to study and I'm sick of mindless doom-scrolling on Instagram Reels and YouTube."

Every recommendation engine on the web gives either generic lists ("100 things to do when bored") or tries to sell you commercial events and movie tickets you can't afford. None of them understand that:

You only have ₹100 or ₹200 left in your UPI wallet.
You're physically stuck in a college hostel or bedroom.
You have low energy and specifically do not want to study or cook.

The Solution: The Core Equation

NowWhat? replaces choice overload with a sequential, realistic, timed itinerary built around the user's exact reality:

TIME + MOOD + PEOPLE + LOCATION + BUDGET + ENERGY + PREFERENCES
                             ↓
                      OPEN-SOURCE AI
                             ↓
                PERSONALIZED FREE-TIME PLAN

Instead of a random laundry list, it sequences an intentional flow:

4:00 PM — ☕ Brew an adrak chai on the hostel induction (20 min, ₹20)
4:20 PM — 🚶 30-minute neighborhood photo walk in airplane mode (30 min, Free)
4:50 PM — 🎧 Curate a 7-song hyper-specific memory playlist (35 min, Free)
5:25 PM — 🎬 Watch "12th Fail" or "The Secret Life of Walter Mitty" (115 min, Streaming)

Every activity comes with the exact duration, cost, why the AI selected it, actionable tips, and movie/show cards with streaming platforms when appropriate.

Demo

- **DEMO URL: https://trideep091.github.io/now-what/

Key Capabilities in Action:

Natural One-Sentence Prompt Input:
Users don't even have to fill a form. They can type naturally into the hero bar:

"Bro, I'm alone in my hostel, have 4 hours and ₹200. I'm bored but I don't want to study."
The AI parses the parameters (4 hours, hostel, ₹200 budget, low/medium energy, "no studying" exclusion) and outputs a chronologically budgeted plan.
9-Step Deep Personalization Wizard:
- Time: 30 min, 1 hr, 2 hrs, 3 hrs, 4+ hrs, or custom
- People: Just me, Partner, Friends, Family, Group
- Location: At home, Hostel, Campus, Outdoors, City, Cafe, Anywhere
- Mood: Bored, Relaxed, Energetic, Curious, Creative, Social, Tired, Adventurous
- Energy: Low, Medium, High
- Budget: ₹0 (Free), Under ₹100, ₹100–₹300, ₹300–₹500, ₹500+
- Interests: Watch, Make, Move, Learn, Play, Create, Connect, Explore, Relax, Improve
- Strict Exclusions: "No studying", "No outdoor activities", "No spending money", "No cooking"
- Final Input: Open conversational note
Interactive Boredom Meter:
Playful one-click triage with 4 levels: 😐 Mild, 😑 Medium, 🥱 Very bored, 🚨 Emergency boredom.
Surprise Me Mode:
A streamlined 2-question spontaneous flow when you want the AI to surprise you without thinking.
Saved & History Library:
Full plans and individual activities can be bookmarked to localStorage and revisited anytime.

Code

The full source code is organized into a clean, modular architecture:

Nowwhat/
├── package.json
├── .env.example              # Environment variables template
├── .gitignore                # Protects all secret tokens & dependencies
├── README.md                 # Project documentation & Hackathon submission
├── server/
│   ├── server.js             # Express application & SPA fallback routing
│   ├── routes/
│   │   └── api.js            # REST API (/api/plan, /api/chat-plan, /api/surprise, /api/models)
│   └── ai/
│       ├── aiService.js      # Modular Open-Source AI Orchestrator & Fallback
│       ├── promptTemplates.js# Strict JSON schema prompts & reasoning instructions
│       ├── parser.js         # Semantic natural language intent & parameter parser
│       └── providers/
│           ├── groqProvider.js        # Meta Llama 3.3 70B & 3.1 8B via Groq
│           ├── ollamaProvider.js      # Sovereign Local Ollama GPU inference
│           ├── huggingFaceProvider.js # Open-source Mistral 7B Instruct
│           └── localEngine.js         # Built-in Edge Reasoning Engine (100% offline)
└── public/
    ├── index.html            # Responsive single-page application shell
    ├── css/
    │   ├── style.css         # Dark sophisticated tokens, typography, glassmorphism
    │   └── components.css    # Wizard stepper, timeline cards, boredom meter, drawer
    └── js/
        ├── app.js            # Router, state management, toast notifications
        ├── wizard.js         # 9-Step interactive wizard & progress math
        ├── timeline.js       # Chronological timeline renderer, copy, feedback
        ├── surprise.js       # Fast surprise flow
        ├── boredomMeter.js   # Interactive boredom level selector
        └── openAiShowcase.js # Architecture explorer & model switcher

Quick Setup & Run:

# Clone the repository
cd Nowwhat

# Install dependencies
npm install

# Start the server
npm start

Open http://localhost:3000 in your browser.

How I Built It

The stack was chosen for maximum responsiveness, zero framework bloat, and modular AI swappability:

Frontend:
- HTML5 & Vanilla CSS3: Crafted with a dark startup aesthetic (#080A0E background, warm cream typography #F8F6F0, subtle orange/amber #FF7A30 accents), glassmorphism (backdrop-filter: blur(20px)), and fluid typography with Google Fonts (Plus Jakarta Sans & Space Grotesk).
- Vanilla JavaScript: Zero heavy bundle overhead. Fast loading, responsive client-side routing, and interactive DOM manipulation.
Backend:
- Node.js & Express: Lightweight REST API that serves the frontend, handles CORS, and encapsulates AI credentials so API keys are never exposed to client-side code.
Open-Source AI Core:
The heart of NowWhat? is completely decoupled from any single proprietary vendor. It features a Modular AI Adapter Layer (server/ai/aiService.js):
- Meta Llama 3.3 70B & Llama 3.1 8B (Open Weights via Groq): Provides high-speed conversational reasoning and natural-language constraint extraction.
- Self-Hosted Ollama (127.0.0.1:11434): Connects to sovereign open models (llama3:8b, mistral, deepseek-r1) running directly on a local GPU for 100% offline, private execution.
- Mistral 7B Instruct (Hugging Face): Open-source European instruction model.
- NowWhat? Built-In Edge Reasoning Engine: A deterministic, constraint-satisfaction offline engine that runs out of the box with zero API keys required, calculating exact sequential clock times (4:00 PM → 4:35 PM → 5:15 PM), enforcing strict budget caps in INR (₹), and filtering out exclusions.

Why Does Open Innovation Matter?

Open innovation and open-source AI are not just technical details in NowWhat?—they are the ethical backbone of the product:

1. Radical User Privacy

Planning your free time requires sharing intimate personal data: your emotional fatigue, your financial budget, who you are with, and your physical location (hostel room, campus, home). Sending this life telemetry to closed, proprietary models exposes users to commercial tracking and advertising profiles. Open-weight models can run locally or via dedicated sovereign servers where data is never retained or monetized.

2. Offline & Sovereign Availability

Students in hostels with spotty WiFi, commuters on trains, or travelers in remote locations often need boredom relief the most. Because NowWhat? supports local open models via Ollama and an offline edge engine, the app works 100% disconnected from the internet.

3. Inspectability & Zero Dark Patterns

Closed commercial search algorithms are filled with dark patterns: when you ask for "something to do", they subtly steer you toward ticketed events, sponsor restaurants, and consumer products. Open-source prompts and models are fully inspectable, auditable, and transparent.

4. Model Swapping & Freedom from Vendor Lock-In

We aren't trapped in any single company's pricing changes, deprecation cycles, or rate limits. We can swap between a lightweight 8B model on a MacBook to a 70B model or a community fine-tune with a single line in .env.

My Agent Session

This project was built pair-programming with Antigravity, Google DeepMind's advanced agentic coding environment:

Architected the full end-to-end stack: modular Express backend, REST APIs, and responsive vanilla frontend.
Iterated on the 9-step wizard and conversational prompt parser to extract real-world constraints (like hostel rooms, ₹150 budgets, and "no studying" rules).
Implemented the chronological time calculation engine and verified that assets load seamlessly whether opened via http://localhost:3000 or double-clicked from Finder (file://).

Prize Categories

Hacktoberfest Weekend Challenge: Build for a Friend
Best Use of Open-Source AI / Open Weights
Most Practical & Creative Consumer Web App

Built with open-source AI. Because free time should be an adventure, not an algorithm trap.