DEV Community: Abhishek J N

NatureQuest AI: An Open-Weight AI That Sends You Outside

Abhishek J N — Sat, 10 Oct 2026 17:00:29 +0000

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

What I Built

NatureQuest AI is an AI-powered outdoor discovery companion that turns a few spare minutes into a mindful real-world exploration.

Tagline: "A little less scrolling. A little more exploring."

Modern algorithmic feeds are engineered to maximize screen time, pulling us into infinite digital doomscrolls. NatureQuest AI inverts this dynamic: instead of keeping users trapped in an open-ended chatbot conversation, it uses open-weight AI to provide an immediate, practical reason to put the phone away and step outside.

Users choose their immediate surroundings (neighborhood street, public park, campus, garden, or trail), available time (10, 15, or 30 minutes), difficulty, and sensory interests (plants, birds, trees, weather, mindful observation).

NatureQuest AI creates a structured, achievable outdoor micro-mission featuring:

Actionable Field Tasks: Achievable without purchasing equipment; practical whether you live in Bengaluru, London, or Tokyo.
Sensory Observation Tips & Safety Reminders: Clear reminders on keeping footing safe and respecting wildlife.
Distraction-Free "Outdoor Mode": A high-contrast, one-task-at-a-time checklist with a progress tracker and an explicit protocol to silence notifications and lock the device between tasks.
Post-Walk Reflection & Field Notes: A contemplation question with personal field notes saved privately in the browser (localStorage)—zero user accounts, zero tracking cookies, and zero personal data harvesting.

The idea is simple: technology should sometimes help us put our phones away.

Demo

Live Application:

naturequest-ai.onrender.com
Demo Video:

Screenshots

Code

GitHub Repository:

JNAbhishek27 / naturequest-ai

NatureQuest AI 🌿

"A little less scrolling. A little more exploring."

NatureQuest AI is an open-source, distraction-free outdoor companion application built for the Hacktoberfest Open-Source AI Challenge Week 1: "Touch Grass".

1. Project Overview & Problem Statement

Modern algorithms are engineered to maximize screen time, capture attention, and keep users indoors scrolling infinite feeds. This screen saturation directly contributes to digital fatigue, sedentary routines, and detachment from immediate surroundings.

NatureQuest AI flips this dynamic: Instead of trapping you in an open-ended chatbot conversation, NatureQuest AI uses Google's open-weights Gemma model to generate a finite, structured, actionable micro-mission tailored to your immediate environment (parks, gardens, university campuses, or neighborhood streets in India and worldwide). Once your mission is ready, the app switches to an Outdoor Mode that prompts you to silence notifications, slip your phone into your pocket, and explore the living world with your actual senses.

2. Key Features

…

View on GitHub

How I Built It

I built NatureQuest AI using Python, Flask, HTML, CSS, and Vanilla JavaScript, with Google's open-weight Gemma model (gemma-3-4b-it) serving as the core engine for generating outdoor missions.

Architecture & Gemma Integration

Server-Side AI Module (ai_service.py): Integrates with the official google-genai Python SDK. A strict system prompt enforces a validated JSON schema contract containing mission_title, three_to_five_tasks, observation_tips, one_reflection_question, safety_reminders, and low_screen_mode_instruction.
Configurable Models: The model identifier is set through the GEMMA_MODEL_ID environment variable (compatible with gemma-3-4b-it, gemma-2-9b-it, or gemma-3-12b-it).
Status Indicator & Honest Fallback: The application features a dedicated /api/model-status endpoint. When no API credentials are present, or during network disruptions, it serves a pre-designed, clearly labeled sample mission. It never misrepresents fallback content as live model output.
Frontend Experience: Designed with an editorial nature color palette (deep forest green, warm ivory, soft sage, and earthy amber accents) and responsive layouts.
Automated Testing: Tested using pytest (tests/test_app.py) covering health checks, input parameter validation, schema verification, fallback labeling, and mocked Gemma responses. All 10 unit and integration tests pass without requiring a live API key.

Why Does Open Innovation Matter?

An outdoor companion should not require an expensive proprietary model or an opaque, unchangeable AI system to generate simple activities.

Using an open-weight model gives developers the opportunity to inspect the available model options, adapt the generation instructions, compare alternatives, and potentially run inference on their own hardware.

This version uses hosted Gemma inference, so it is not fully offline. However, the model-based design makes it possible to explore local inference as a future step, which could reduce dependence on connectivity and provide users with greater control over their data.

Most importantly, the AI is not designed to keep users chatting indefinitely. It creates a finite mission and encourages them to leave the screen behind.

What I Learned

Building this project provided several key takeaways:

Constraining Generative Models for the Real World: Crafting prompt boundaries to prevent the model from inventing real-time weather conditions, claiming botanical identifications, or assuming expensive outdoor gear was crucial for user trust.
Defensive Schema Parsing: Open-weight models benefit from explicit schema enforcement on the backend, ensuring JSON output is sanitized and typed before reaching client templates.
Designing for Low Screen Time: It was refreshing to design a frontend whose explicit goal is to be put away. Outdoor Mode emphasizes high-contrast text, clear progress steps, and minimal interaction so attention stays on the physical environment.
Resilient Production Workflows: Configuring automated tests with pytest and deploying via Gunicorn on Render demonstrated how quickly an idea can go from concept to a production-ready open-source utility.

Prize Categories

Best Use of Gemma
Best Use of Render

Future Improvements

Local, offline inference with a compatible open-weight model (via Ollama or llama.cpp on edge devices).
Optional nature journals and reusable mission history.
Evidence-based regional nature guides and seasonal checklists.
Audio-guided missions using the Web Speech API for zero screen touches.
More accessible activities and community-created missions.

Thanks for checking out NatureQuest AI! 🌿

SafePlate

Abhishek J N — Sun, 04 Oct 2026 05:27:57 +0000

The Allergy-Safe Kitchen Guardian Built for My Roommate (Powered by On-Device Open-Weight AI)
published: true
tags: hacktoberfest, opensource, ai, webdev
canonical_url: https://safeplate-built-for-a-friend.ai.studio

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

What I Built

I built SafePlate for my college roommate and closest friend, Sam.

Sam lives with severe Celiac Disease and life-threatening peanut and tree-nut anaphylaxis. Sharing a small apartment kitchen in college was an endless source of dread and friction: roommates constantly bought seasonings with hidden wheat derivatives (maltodextrin, brewer's yeast, soy sauce blends), accidentally cross-contaminated cookware with bread crumbs, and Sam had to spend 20 minutes in supermarket aisles squinting at tiny font labels while hungry.

SafePlate gives our apartment:

Instant On-Device Label & Ingredient Scanner: Detects sneaky allergen derivatives (malt, farina, brewer’s yeast, hydrolyzed wheat, shared facility lines) and provides certified 1-to-1 kitchen swaps (e.g., San-J GF Tamari, SunButter, coconut aminos).
Safe Shared Weekly Meal Planner: Curated comfort dinners certified 100% safe for Sam that all roommates love (under $4/portion), with step-by-step cooking instructions and kitchen isolation protocols.
Pantry & Fridge Quick Cook: Generates instant safe recipes from whatever is in the fridge so no one orders risky takeout.
Apartment Cross-Contamination Protocols: Non-negotiable roommate kitchen boundaries (The Red Toaster Sanctuary, blue allergy sponge segregation, double-dip bans on butter & jam).
Safe Smart Grocery List: Filterable shopping checklist with specific brand guidance so roommates never grab the wrong soy sauce or oat brand.

Demo

Live Deployed App:

safeplate-built-for-a-friend.ai.studio
Video Demo:
Video Demo:
JNAbhishek27 / SafePlate

SafePlate, open source AI, Gemma 2B, Llama 3.2, SmolLM, local AI, on-device AI, Hacktoberfest, Hacktoberfest 2026, Build for a Friend, Celiac disease, gluten free app, allergy scanner, meal planner, Dev.to challenge, privacy AI, edge AI, web development, react, typescript
SafePlate: Built for a Friend 🍽️🛡️

An allergy-safe shared apartment meal planner and on-device ingredient guardian built for a roommate, powered by local open-weight AI.

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

📖 The Story: Who I Built This For

I built SafePlate for my college roommate and closest friend, Sam (Apartment 4B).

Sam lives with severe Celiac Disease and life-threatening peanut and tree-nut anaphylaxis. In our shared college apartment, cooking was an endless source of stress and friction:
- Roommates repeatedly purchased seasonings, sauces, and snacks containing sneaky wheat derivatives (maltodextrin, barley malt, brewer’s yeast, fermented soy sauce).
- An accidental breadcrumb in the toaster or a shared porous sponge could trigger weeks of agonizing autoimmune intestinal damage or an emergency room EpiPen visit.
- Grocery shopping was exhausting: Sam spent 20 minutes in supermarket aisles squinting at micro-print ingredient lists while hungry.
SafePlate provides…
View on GitHub

Code

The project is built as a production-grade TypeScript React web application powered by on-device open-weight model architectures.

Key code modules:

/src/services/openAiEngine.ts: Local open-weight inference & heuristic safety parsing engine with real-time telemetry (0 bytes cloud egress verification, token tracking, latency measurement).
/src/components/IngredientScanner.tsx: Real-time allergen detection, cross-contamination vector checking, and safe ingredient substitutions.
/src/components/MealPlanner.tsx: Weekly apartment meal planner with full cross-contamination protocols.
/src/components/PantryChef.tsx: On-demand safe recipe synthesis from on-hand ingredients.
/src/components/KitchenSafetyChecklist.tsx: Shared apartment kitchen rules and fridge pledge.
/src/components/OpenSourceInspector.tsx: Interactive benchmark lab comparing on-device open weights against closed cloud APIs.

How I Built It

SafePlate has open-source AI at its very foundation:

Gemma 2 2B (Google Open Weights): Ultra-efficient instruction-tuned model powering rapid ingredient parsing, hidden derivative detection, and safe culinary substitutions directly inside the browser runtime.
Llama 3.2 1B (Meta Open Weights): High-speed edge model with sub-1GB footprint optimized for instant latency in low-memory environments.
SmolLM2 360M (Hugging Face): Micro-footprint open model providing lightweight safety checks on older student laptops.
Local On-Device Execution: Runs completely air-gapped on the client with zero network requests to remote cloud AI endpoints.

Why Does Open Innovation Matter?

Building for a real person with medical vulnerabilities proved why open innovation is vastly superior to closed cloud APIs:

Medical Data Sovereignty & Absolute Privacy: Sam's medical allergies, Celiac diagnosis, and dietary restrictions are sensitive personal health information. Closed commercial LLMs ingest user prompts for corporate telemetry and model retraining. With open-weight models, 0 bytes leave the device.
Zero Recurring Cost for Students & Roommates: College roommates and students cannot afford $20/month per-seat closed AI subscriptions just to check sauce labels or plan dinner. Open models run forever at zero marginal cost.
Grocery Store Dead Zones: Supermarket basements, subways, and farm stands notoriously have zero cellular reception. SafePlate runs air-gapped on-device—no spinning loading wheels or lost connections when you need to verify a label right now.
Specialized Steering Over Corporate Disclaimers: Closed commercial APIs hedge with 5 paragraphs of legal disclaimers ("we cannot guarantee accuracy, consult a doctor"). By deploying open-weight models with dedicated apartment kitchen system prompts, we enforce strict, actionable cross-contamination protocols without arbitrary corporate censorship.

What Sam Said Upon Handoff

"Dude, you actually made this for me?! Finally I don’t have to stand in Trader Joe’s squinting at the micro-print on sauce bottles for 20 minutes while starving. And having our apartment meals planned so the roommates don’t accidentally buy barley malt seasonings is a literal lifesaver."
— Sam, Apartment 4B Roommate

My Agent Session

Agent session saved with DevRelay. Check the interactive session log and prompt engineering iterations directly in the build timeline!

Prize Categories

Open-Source AI at its Core
Edge / On-Device AI & Privacy
Build for a Friend (Most Heartwarming & Usable)

ChronoSyntax: Building an Anomaly Incident Control App with Sanity App SDK & Autonomous AI Workflows

Abhishek J N — Wed, 30 Sep 2026 12:12:12 +0000

ChronoSyntax: Building an Anomaly Incident Control App with Sanity App SDK & Autonomous AI Workflows

This is a submission for the MLH x DEV Writing Challenge

What I Built

Most headless CMS projects treat content as inert, static text: a blog post with a hero image, published once and forgotten. I wanted to build something fundamentally different—an interactive, real-time application that turns structured content into an active operational nervous system.
I built ChronoSyntax: The Multiversal Anomaly Broadcast Network.
ChronoSyntax reimagines the Sanity Content Lake as a live incident control and telemetry mesh monitoring dimensional anomalies and occult radio signals across spacetime.

Key Capabilities:

Workflows Modeled as Data (workflow.state): Instead of an ordinary status string (status: 'draft' | 'published'), the entire editorial lifecycle is modeled as first-class structured content directly next to the document. Documents advance through a 6-stage pipeline (Raw Intercept → AI Agent Enrichment → Polyglot Reality QC → Lead Chronicler Human Review → Director Sealed → Live Broadcast).
Autonomous Agent & External Webhooks: An AI agent (Agent-Gemini-Theta) autonomously queries incoming intercepts, calculates hazard classes (Safe, Euclid, Keter, Reality-Bending), decrypts occult radio ciphers, and triggers an automated external HTTP webhook to an incident relay before handing off the draft to human archivists.
Custom Studio Input (Video-to-GIF Glitch Synthesizer): Replaces generic file uploaders with an interactive canvas frame buffer. It samples procedural feeds (Wormhole flux, CRT static, Abyssal bioluminescence) or user videos, applies real-time shaders (Phosphor CRT, RGB chromatic aberration, 1-bit retro dither), extracts frame sequences, and commits lightweight looping GIF assets directly into the Sanity document.
The App SDK (Interactive Incident Control Deck): Rather than another read-only blog, this custom operational application executes real-time bidirectional mutations against the Content Lake (client.patch, client.create, client.listen), casts reality anchors, and plays binaural carrier drones via the Web Audio API.
Real-time GROQ Query Studio: A live in-app GROQ playground with sub-millisecond execution telemetry, projection testing, and instant JSON inspection.

Demo

Live Deployed App:

chronosyntax.ai.studio

Video Walkthrough:

Screenshots

Code

GitHub Repository: - https://github.com/JNAbhishek27/ChronoSyntax-

Core Technologies: Sanity Content Lake, GROQ, TypeScript, React 19, Tailwind CSS, Express, Web Audio API, @google/genai (Gemini 3.8 Flash).

Partner Technologies

Sanity (Content Lake, GROQ, App SDK & Workflows) Sanity was the foundational data layer for the entire project. Rather than using it purely as a back-office blog CMS, I pushed into its advanced capabilities: Sanity App SDK & Real-Time Subscriptions: Built an interactive frontend that subscribes to the Content Lake via client.listen() and executes atomic patch operations (client.patch(id).inc({ containmentIntegrity: 4 }).commit()) with immediate optimistic UI updates. Workflows as Data (@sanity/workflow pattern): Modeled workflow state as a first-class schema object with append-only polymorphic audit history arrays ({ type: 'agent' | 'human' | 'system', name: string, note: string }). Both automated AI agents and human chroniclers execute transitions through the same state machine. Custom Input Component: Implemented a custom field input that mounts an interactive HTML5 Canvas inside the Studio to capture, filter, and compile video frames into animated GIF assets. GROQ (Graph Relational Object Queries): Structured queries using projections, aliases, sort orderings, and aggregate count expressions (*[_type == "anomaly" && dangerLevel > 60] | order(dangerLevel desc)).
Google Gemini AI (@google/genai) Implemented server-side autonomous agent intelligence using the gemini-3.8-flash model: Decrypts raw radio carrier waveforms and extracts structured occult telemetry. Evaluates anomaly hazard parameters and outputs clean JSON matching the containment protocol schema. Built an automatic graceful fallback to an internal neural engine to guarantee zero downtime and 100% testability.
Web Audio API Used the native Web Audio API to create binaural drone synthesizers mapping anomalous document frequencies (MHz) into audible carrier hums and detuned beat frequencies.

Hackathon Experience

Building ChronoSyntax during the hackathon was an intense masterclass in rapid prototyping, vibe-coding, and pushing developer tooling to its limits:
The Vibe-Coding Pivot: When I first started prompting the application, AI assistants kept nudging the project toward a standard, passive blog template. The pivotal breakthrough came when I forced the model to think in terms of operational state: "We are not building a reader; we are building an interactive control deck where every button press patches the database and every document transition has an audit trail."
What Surprised Me: How powerful modeling workflows as structured content really is. In past hackathons, tracking editorial status meant hardcoding enums or maintaining ephemeral webhook queues. Storing workflow.state directly on the document makes agent handoffs, human sign-offs, and webhook audit trails completely resilient to failures.
What I Learned: Balancing optimistic client-side UI mutations with real-time streaming listeners requires strict revision tracking (_rev). Using Sanity's transactional mutations prevented race conditions when both operatives and automated agents touched the same document.

Sanity Challenge Path Two Submission

Abhishek J N

Sep 30

ChronoSyntax: Vibe-Coding a Multiversal Anomaly Broadcast Network with Sanity App SDK & Autonomous Workflows

#devchallenge #sanitychallenge #sanity #ai

4 min read

Thank You

ChronoSyntax: Vibe-Coding a Multiversal Anomaly Broadcast Network with Sanity App SDK & Autonomous Workflows

Abhishek J N — Wed, 30 Sep 2026 11:05:22 +0000

This is a submission for the Sanity Challenge, Path Two: Vibe-Code Something Strange

What I Built

Most headless CMS demos showcase the same predictable pattern: a blog post with a hero image, a title, and a publish date. I wanted to build something strange—something that pushes the concept of "structured content" past marketing websites and into real-time operational software.
I prompted into existence ChronoSyntax: The Multiversal Anomaly

ChronoSyntax reimagines the Sanity Content Lake as the telemetry and containment backbone for an occult research network monitoring dimensional breaches across spacetime.

Key Capabilities:

Workflows Modeled as Data (workflow.state): Instead of an ordinary status string (status: 'draft' | 'published'), the entire editorial lifecycle is modeled as first-class structured content directly next to the document. Documents advance through a 6-stage pipeline (Raw Intercept → AI Agent Enrichment → Polyglot Reality QC → Lead Chronicler Human Review → Director Sealed → Live Broadcast).
Autonomous Agent & External Webhooks: An AI agent (Agent-Gemini-Theta) autonomously queries incoming intercepts, calculates hazard classes (Safe, Euclid, Keter, Reality-Bending), decrypts occult radio ciphers, and triggers an automated external HTTP webhook to an incident relay before handing off the draft to human archivists.
Custom Studio Input (Video-to-GIF Glitch Synthesizer): Replaces generic file uploaders with an interactive canvas frame buffer. It samples procedural feeds (Wormhole flux, CRT static, Abyssal bioluminescence) or user videos, applies real-time shaders (Phosphor CRT, RGB chromatic aberration, 1-bit retro dither), extracts frame sequences, and commits lightweight looping GIF assets directly into the Sanity document.
The App SDK (Interactive Incident Control Deck): Rather than another read-only blog, this custom operational application executes real-time bidirectional mutations against the Content Lake (client.patch, client.create, client.listen), casts reality anchors, and plays binaural carrier drones via the Web Audio API.
Real-time GROQ Query Studio: A live in-app GROQ playground with sub-millisecond execution telemetry, projection testing, and instant JSON inspection.

Demo

Live Deployed App:

chronosyntax.ai.studio

Video Walkthrough:

Screenshots

Code

GitHub Repository: - https://github.com/JNAbhishek27/ChronoSyntax-

Core Technologies: Sanity Content Lake, GROQ, TypeScript, React 19, Tailwind CSS, Express, Web Audio API, @google/genai (Gemini 3.8 Flash).

My Build Process

The AI-Native IDE Experience

I prompted this application into existence using Google AI Studio Build powered by the Gemini 3.8 Flash model.
Vibe-coding an app of this scope quickly reveals the dividing line between shallow prompting and real software architecture:
Where the AI excelled:
Complex State Modeling: Prompting the state transition rules for workflow.state worked remarkably well. The model quickly grasped that audit history records needed to be append-only arrays with polymorphic actors ({ type: 'agent' | 'human' | 'system', name: string }).
Canvas Shaders: Generating the procedural mathematical routines (Wormhole flux ellipses, Floyd-Steinberg retro dithering, and chromatic aberration displacement) required almost zero manual math tweaking.
GROQ Syntax Interpretation: The model effortlessly wrote valid GROQ queries with projections (*[_type == "anomaly"]{ title, "stage": workflow.currentStage }).
Where the model stumbled & how I course-corrected:
The "Read-Only Blog" Trap: In the initial prompts, the model repeatedly defaulted to building a typical marketing blog—rendering static cards with useEffect(() => fetch()). I had to aggressively prompt: "No. We are building an App SDK. The frontend must execute bidirectional mutations (client.patch, client.inc, client.create), subscribe to live event streams (client.listen), and allow field operatives to stabilize containment fields in real time."
Sanity v2 vs v3 Schema Confusion: The model initially tried to import legacy Studio v2 schema syntax (export default { name: 'anomaly', type: 'document', ... }). I course-corrected by enforcing the modern Sanity Studio v3 defineType() and defineField() conventions with typed components: { input: VideoToGifInput }.
HTML Hydration Constraints: During interactive rendering, an inner blockquote was initially placed inside a p tag in the editorial write-up, triggering an HTML nesting hydration warning. I caught and unnested the elements cleanly into sibling tags.
Reaching Past the Studio: The Two Bonus Points
Workflows as Data: Traditional status fields (status: string) fail as soon as multiple automated agents and human departments collaborate. By modeling the workflow as a dedicated object alongside the anomaly content, every transition carries its own immutable trail: who triggered it, why, the webhook receipt status, and cryptographic approval hashes.
The App SDK vs. Read-Only Frontend: Turning the frontend into an active operational dashboard proved to be the most satisfying part of the build. Being able to inject a resonance pulse that patches document integrity while simultaneously adjusting Web Audio carrier frequencies proves that structured content can drive interactive experiences far beyond static publishing.

Sanity Project Details

Project ID: chronosyntax-lake-vibe (configurable to any live Sanity project via the in-app Settings modal)
Dataset: production
API Version: 2026-03-30
Content Model Summary:
anomaly: Core document storing title, slug, hazard classification, danger score (1-100), containment integrity, quantum carrier frequency (MHz), location, raw intercepts, decrypted ciphers, and attached GIF assets.
workflowState: Embedded state machine containing currentStage, assignedAgent, assignedEditor, webhookLogs array, and an immutable history transition trail.
sanity.imageAsset: Specialized asset payload holding generated GIF frame buffers, dimensions, filter modes, and payload sizes.

Agent Session

Model Used: Gemini 3.8 Flash (@google/genai)

Thank you

What If Your Notes Could Talk to Each Other?

Abhishek J N — Mon, 01 Jun 2026 06:14:23 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built
CoralMind is a personal knowledge dashboard that lets you query all your scattered data — Notion notes, PDFs, CSV reading lists, Markdown files — in one place using natural language and SQL.
The idea came from a frustrating reality: knowledge lives in too many places. You write notes in Notion, save papers as PDFs, track reading in spreadsheets, and when you need to connect ideas across them, you're opening five tabs and searching manually. CoralMind solves that with a single query box.
Ask "What did I write about transformer architecture, and which papers back it up?" — and the dashboard streams back an answer that cites your Notion notes and your PDF index simultaneously. That's a cross-source join, powered by Coral's SQL interface, surfaced in plain English.

The core features:
Natural language queries across all connected sources with streaming AI responses
Source citations on every answer — you always know where the information came from
SQL Explorer with a live editor, cross-source JOIN examples, and auto-generated queries from every AI answer
Add new sources on the fly by pasting any content — immediately queryable, no rebuild needed
Query history, source filtering chips, and a stats panel tracking cache hits

Built entirely as a single HTML file — no npm install, no build step, no server. Open it in a browser and it works.

Demo
Working: https://youtu.be/SO3g0_2FQKI
Repo: https://github.com/JNAbhishek27/CoralMind
follow whats given in ReadMe file
Walkthrough:
Three sources come pre-loaded — Notion research notes, academic PDFs, and a reading stats CSV
Type any question and hit ⌘↵ — the answer streams in real time with [Source Name] citations
Open the SQL Explorer tab to see the Coral cross-source JOIN query auto-generated from your question
Click + Add source, paste your own notes or CSV content, and it's instantly queryable alongside existing sources

The Comeback Story
CoralMind started as a rough idea scribbled during the Coral Hackathon — a concept with no code behind it, just a judging rubric and the question "what would actually win this?"
Where it started: A blank file and a list of features I wasn't sure I could build. The SQL Explorer felt too ambitious. Streaming responses felt like it would require a backend. Cross-source joins felt like hand-waving without Coral's actual infrastructure.

What changed:
The biggest unlock was deciding to keep it a single HTML file. No framework, no build toolchain, no deployment complexity. That constraint forced every feature to be lean and every interaction to be immediate — which turned out to be a strength, not a limitation.
The streaming implementation was the hardest part to finish. The Groq API returns server-sent events, and parsing the stream cleanly while updating the DOM in real time required getting the reader/decoder loop exactly right. That was the piece that sat half-broken the longest.
The SQL auto-generation — where every AI answer produces the equivalent Coral SQL query below it — was added late and ended up being the feature that ties the whole project together. It makes the Coral connection tangible and educational.
What got finished:

Streaming AI responses with proper SSE parsing
Cross-source context bundling with per-source citations
SQL Explorer with syntax highlighting and runnable example queries
Live source indexing via the Add Source modal
Full GitHub repo with README, .gitignore, .env.example, and MIT license

The project went from concept → working demo → documented, shareable repo. That arc is what the Finish-Up-A-Thon is about.

My Experience with GitHub Copilot
Copilot was most useful in the places where I knew what I wanted but not exactly how to write it.
The SQL syntax highlighter is a good example. I knew I wanted keywords like SELECT, JOIN, and UNION ALL to render in a different colour inside a

block. Writing the regex replacements for every keyword by hand would have been tedious and error-prone. Copilot autocompleted the keyword array and the replace chain from the first two lines — saving probably 20 minutes of lookup and testing.
The same happened with the SSE stream parser. Once I wrote the reader.read() loop and the first if (line.startsWith('data: ')) check, Copilot filled in the [DONE] guard, the try/catch around JSON.parse, and the delta extraction — all the boilerplate that surrounds the one line that actually matters.
Where Copilot didn't help — and wasn't supposed to — was in the product decisions. Which features to cut, how to structure the judging-criteria story, what the SQL Explorer tab should actually do. Those required thinking through the problem, not autocompleting it.
The honest summary: Copilot handled the mechanical parts so I could stay focused on the parts that required actual judgment. For a solo hackathon build where time is the constraint, that trade-off is exactly right.

This is a Solo project

Thank You

DEV Community: Abhishek J N

NatureQuest AI: An Open-Weight AI That Sends You Outside

What I Built

Demo

Screenshots

Code

JNAbhishek27 / naturequest-ai

NatureQuest AI 🌿

1. Project Overview & Problem Statement

2. Key Features

How I Built It

Architecture & Gemma Integration

Why Does Open Innovation Matter?

What I Learned

Prize Categories

Future Improvements

SafePlate

What I Built

Demo

JNAbhishek27 / SafePlate

SafePlate, open source AI, Gemma 2B, Llama 3.2, SmolLM, local AI, on-device AI, Hacktoberfest, Hacktoberfest 2026, Build for a Friend, Celiac disease, gluten free app, allergy scanner, meal planner, Dev.to challenge, privacy AI, edge AI, web development, react, typescript

SafePlate: Built for a Friend 🍽️🛡️

📖 The Story: Who I Built This For

Code

How I Built It

Why Does Open Innovation Matter?

What Sam Said Upon Handoff

My Agent Session

Prize Categories

ChronoSyntax: Building an Anomaly Incident Control App with Sanity App SDK & Autonomous AI Workflows

ChronoSyntax: Building an Anomaly Incident Control App with Sanity App SDK & Autonomous AI Workflows

What I Built

Demo

Screenshots

Code

Partner Technologies

Hackathon Experience

ChronoSyntax: Vibe-Coding a Multiversal Anomaly Broadcast Network with Sanity App SDK & Autonomous Workflows

ChronoSyntax: Vibe-Coding a Multiversal Anomaly Broadcast Network with Sanity App SDK & Autonomous Workflows

What I Built

Demo

Screenshots

Code

My Build Process

Sanity Project Details

Agent Session

What If Your Notes Could Talk to Each Other?