DEV Community: dhruv

Disruption Desk: flight rights with a paper trail

dhruv — Sun, 04 Oct 2026 14:38:39 +0000

This is a submission for the Sanity Challenge, Path One: Ship an Agent That Queries Real Content

What I Built

Disruption Desk helps passengers work out what they may be entitled to after a flight disruption.

A cancellation or long delay can leave you reading regulations, airline policies and guidance pages that answer slightly different questions. Compensation, refunds and care also have different conditions. Being entitled to one does not necessarily mean you qualify for the others.

I built a flight facts form that turns those conditions into a sourced assessment. You enter the route, carrier, disruption and relevant details. The app returns an amount where it can determine one, the applicable entitlements, and the sources behind the result. Missing facts and unsupported cases stay visible.

The app covers selected passenger-rights rules for the EU, UK, US and India. Indian coverage includes cancellation, involuntary denied boarding, delay assistance and specific connecting-flight situations. Baggage results provide claims guidance; an individual loss still needs individual evidence.

The stack is Next.js 16, the Vercel AI SDK and Gemini, deployed on Vercel.

One deliberate constraint: the model cannot write the compensation amount. A calculation function applies the structured rules and returns the money, conditions and citations. Gemini retrieves content and completes the review through tools.

Demo

Open Disruption Desk

No login is required. You can start with an example, change the facts and run a fresh assessment.

For the production check, I submitted this case through /api/ruling:

An IndiGo domestic flight on 1 October 2026 was cancelled with no notice. The scheduled block time was 60 minutes, and the basic fare plus fuel surcharge was ₹6,000. The passenger had a confirmed booking, provided contact details and did not accept an alternative flight. No extraordinary-circumstances defense was proven. What applies?

The result was ₹5,000 compensation, with the ticket refund separate. It also returned refund-process and escalation guidance, citing the DGCA cancellation and refund sources stored in Sanity.

That request completed in about ten seconds with the runtime reporting FULL, google and SANITY_LIVE.

Code

GitHub repository

The repository includes the content model, calculation code, source records and tests.

Validation included 87 passing tests, a successful typecheck and production build, and a 40-case deterministic evaluation. The evaluation is a small, curated suite, so I treat it as a regression check rather than a general claim of legal accuracy. The deployed agent was tested separately against live Sanity content.

How I Used Sanity

I pointed Sanity Context at a dedicated corpus dataset containing corpusDoc documents prepared from passenger-rights source material. These include regulations, official guidance, labeled court summaries and selected airline-policy excerpts. The documents retain source links and provenance.

The structured rules live in the production dataset. Sources, regimes, rules, compensation bands, causes and airline policies are separate documents connected by references.

The agent uses two Context MCP endpoints:

disruption-kb exposes knowledge_base_read for reading the Knowledge Base.
disruption-data exposes groq_query for querying the structured content.

The application prefixes those tool names so their origins are clear. The live production request invoked:

kb_knowledge_base_read
data_groq_query
query_rules
compute_entitlement

The first two calls retrieve through Sanity Context. The application’s query_rules tool then loads a fixed, parameterized GROQ dossier from Sanity, and compute_entitlement applies the conditions to the supplied flight facts.

The structure matters here. For the Indian cancellation example, the calculation needs the block-time band, basic fare plus fuel surcharge, notice period, alternative-flight choice and applicable source version. A paragraph mentioning “cancellation compensation” does not contain enough information by itself to decide the result.

I also kept evaluation scenarios and gap records outside the retrieval scope. The agent should retrieve the rules and evidence, without seeing expected test answers.

The production response included the actual Sanity rule and source IDs behind the ₹5,000 result. Both Context retrievals are required in full mode; a failed retrieval returns an error.

Some limits remain explicit. Court announcements are labeled as summaries, foreign-carrier compensation can need further scope review, and baggage liability ceilings are not presented as automatic payouts.

Sanity Project Details

production: structured sources, rules, regimes, compensation bands and related content.
corpus: source material prepared for the Knowledge Base.

The India update added five official source records, five compensation bands, six structured rules and six corpus summaries to the existing datasets.

Agent Session

I used Codex during implementation and verification, including the Gemini integration and the India rules update.

Spare: you have more to give than you think

dhruv — Mon, 07 Sep 2026 06:52:46 +0000

This is a submission for Weekend Challenge: Generosity Edition

What I Built

Every charity app I've used starts with the same question: how much money can you give. If the answer is not much, you feel a bit guilty and close the tab.

That's the actual problem I wanted to solve. Most people don't skip giving because they're selfish, they skip it because the ask never fits what they actually have. Two hundred rupees feels too small to matter. An hour on a Saturday doesn't feel like "volunteering." An old laptop just sits in a drawer.

Spare flips the question. Instead of asking what you can donate, it asks what you have spare right now, whatever that is: some cash, a free evening, a skill, a language you speak, an object you don't use, access to something like a car or a rooftop. You type it in plain language (any language, any mix, doesn't matter), and Spare reflects it back to you as a little inventory, then gives you three specific things you can actually do with it this week. Not "go volunteer somewhere," but the actual organization, the actual first step, and a message already drafted for you to send.

The thing I cared about most while building this: most tools like this stop at "here's a place near you" and leave you to figure out the rest. Spare tries to close that last gap, because that's usually where good intentions die.

I also didn't want to just trust whatever an AI tells me is a real charity. So every result comes with a label telling you exactly how sure Spare is: confirmed live through search, hand checked by me beforehand, or "search this yourself" if neither of those worked out. I'd rather show you three honest results than five made up ones.

Demo

Live app: https://spareapp.ai.studio

Try the demo personas on the first screen if you don't want to type anything, they'll walk you through the whole flow in a few taps.

Code

GitHub repo: https://github.com/dhruvvvgg/spare

How I Built It

I built this entirely on my phone using Google AI Studio, so the whole thing had to work within that constraint from the start.

The matching works in three layers. First, Gemini does a live search grounded lookup based on what you typed and where you are, and only returns something if it can actually attach a real source link to it, nothing gets shown without a citation. If that comes back empty or thin, it falls back to a list of organizations I manually verified beforehand, checking every single link myself before it went into the app. And if even that doesn't have a good match for what you're offering, it hands you off to a live search on Idealist instead of pretending to have an answer.

I spent a good chunk of the weekend just verifying that fallback list by hand, going through Goonj, Robin Hood Army, eVidyaloka, ConnectFor, HelpAge India, Bhumi, and a few global ones like Translators without Borders and Be My Eyes, checking that each org still exists, still does what it says, and has a live link. It felt slower than just letting the model invent something, but for a project about charity, the last thing I wanted was to point someone toward a fake or defunct organization.

Once you pick one of the three results, a second Gemini call drafts an actual outreach message in your own tone, based on how you phrased your original input, so you're not stuck staring at a blank text box trying to figure out what to even say to a stranger or an NGO.

Prize Categories

Submitting for Best Use of Google AI. Gemini runs the entire pipeline here: pulling structured data out of free text, doing live grounded search for real local opportunities, and writing the final outreach message in your voice.

Chaos Engine: I Built an AI That Settles F1 Pit Stop Arguments

dhruv — Mon, 13 Jul 2026 06:58:48 +0000

This is a submission for Weekend Challenge: Passion Edition

What I Built

I built Chaos Engine, an interactive F1 strategy simulator for people who can't stop arguing about pit calls.

If you've ever watched a race with a die hard F1 fan, you know the argument happens every single weekend. "They should have pitted two laps earlier." "That undercut never had a chance." "Why didn't they just switch to the hards." Every fan thinks they'd have made the better call, and there's never really a way to settle it.

That argument is where this whole project came from. You don't just watch F1, you live and die by strategy calls that happen in about four seconds on a pit wall. So I wanted to build something that actually lets fans test their gut calls against real race data instead of just yelling about it on Reddit or Twitter after the checkered flag.

Chaos Engine takes real F1 races, automatically detects the moments in each one that were statistically the most dramatic (a pit stop that came way earlier or later than everyone else, a sudden pace spike, a big swing in track position), scores the whole race on a "Chaos Score," and then lets you pick one of those moments and rewrite it. Pick an alternate strategy, and the AI reasons over the real degradation curves, pit loss numbers, and traffic gaps from that race to tell you whether your call would have actually worked.

Demo

https://chaos-engine.ai.studio

Code

https://github.com/dhruvvvgg/Chaos-Engine

How I Built It

The whole thing runs on Google AI Studio's Build mode, using Gemini as the actual reasoning engine behind every "what if."

The part I cared most about getting right was making sure the AI wasn't just generating a vibe-y paragraph. I wanted it to actually reason over real numbers, not make something up that sounded plausible. So instead of asking Gemini to freeform explain a scenario, I feed it a structured JSON block for each intervention, real pre-intervention pace data, the pit loss baseline for that race, degradation curves for the tyre compound being chosen, and the gap to nearby cars, and I have it return a structured verdict: predicted position on exit, estimated gap, a verdict of better/worse/roughly equivalent, and a confidence level. That constraint made a huge difference in how trustworthy the output actually felt.

The "chaos moments" themselves aren't hand picked either. I didn't want to sit there and manually decide which lap of which race was interesting, because that doesn't scale and it's basically just my opinion dressed up as data. So those moments come from statistical detection, things like a driver's lap time deviating sharply from their own rolling average, or a pit stop landing way outside the field's typical stop window for that phase of the race. The chaos score for each race is built from those detected anomalies, not from me deciding a race was dramatic because I remember it being dramatic.

I also went back and forth a lot on the UI. I wanted it to feel like an actual race engineering tool, not a generic dashboard template, so I leaned into a dark telemetry aesthetic, glass card treatments, and real F1 data (pole times, fastest laps, laps completed) pulled from the actual race weekends instead of made up placeholder numbers.

Prize Categories

Best Use of Google AI: Gemini is the reasoning engine behind every "what if" in the app, it takes real race data (pace, pit loss, tyre degradation, traffic gaps) and returns a grounded verdict instead of a generic guess, plus it writes the "why was this race chaotic" line on each race card from the detected anomaly data. The whole thing was also built using Google AI Studio's Build mode.