Like Google Maps, Waze is going all-in on Gemini.
Waze is getting an AI makeover. Google is integrating its flagship AI assistant, Gemini, into the driving app with the goal of letting users personalize their trips a little more. Of the four new updates, only two are being described as involving Gemini. Waze says its updating its conversation reporting feature, first introduced in 2024, […]
Hey everyone, We talk a lot about documenting clean architectures and robust APIs, but software engineering history is uniquely shaped by its failures. Documenting these bugs globally usually results in scattered StackOverflow threads or unindexed GitHub issues. I wanted to explore how to build a highly structured, community-driven database dedicated exclusively to tracking software bugs, their deep technical root causes, and multi-language solutions. Here is a technical breakdown of the architectural challenges, data modeling decisions, and security implementations behind building this engine. 1. The Data Modeling Challenge: Structuring the Unstructured Bugs are notoriously hard to normalize in a relational database. A classic logic bug looks nothing like a memory leak or a floating-point precision error. To solve this, we modeled the schema around a strict "Bug DNA" structure using PostgreSQL: Categorization & Multi-Runtime Target: Mapping a single bug to multiple language runtimes dynamically (e.g., how the 0.1 + 0.2 anomaly propagates across V8 JavaScript, CPython, and JVM identically due to hardware constraints). The Diagnostic Timeline: Instead of a generic description text, we structured a linear, time-stamped array to track state changes during the replication phase. 2. Deep Dive: Representing IEEE 754 at the Schema Level Our inaugural entry into the database was the infamous base-2 fractional conversion problem ($0.1 + 0.2 = 0.30000000000000004$). To make this data educational, the challenge was handling how the processor truncates infinite binary fractions: $$0.1_{10} = 0.0001100110011001100110011001100110011001100110011001101..._2$$ We decoupled the storage mechanism so that the raw precision error is stored as a literal string to prevent the database layer (PostgreSQL float types) from auto-correcting or rounding the very bug we are trying to document. 3. Edge Security: Row-Level Security (RLS) Without a Middleware Backend Since the application runs on a
Burn the subscriptions you forgot you had Discussion | Link
Jake Lazaroff discussed the AT Protocol as a framework for distributed applications beyond social networking. He emphasised a local-first architecture where users maintain data in PDSs while leveraging shared infrastructure for synchronisation and updates. The presentation included experiments showcasing collaborative tools and highlighted the benefits of reduced reliance on app-specific backends. By Olimpiu Pop
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, degradat
This is a submission for Weekend Challenge: Passion Edition weekendchallenge. What I Built The project is an east-to-use application which helps user to identify deforestation in areas of interest. From the users selected area of interest, application downloads the satellite images, generates ndvi(Normalized Difference Vegetation Index), and identifies potentially deforested locations based on calculated vegetation indices. My goal was to evaluate the capabilities of AI agents in developing a complete application, production-ready with instructions provided by human. The project also explores the time required to build such an application with AI-assisted software. Demo https://huggingface.co/spaces/sgharti/crop-health Code https://huggingface.co/spaces/sgharti/crop-health/tree/main How I Built It I developed a plan for core software architecture and directed the entire application workflow including the following: Describing entire application lifecycle from user input to fastapi pipeline (GEE and Snowflake). Described the interface specification(leaflet map, design and user input) Described pipeline of how system connects to GEE, generates NDVI(Normalized Difference Vegetation Index) and stores in the Snowflake. Described the workflow of backend-frontend synchronization to read logs from snowflakes and display it on the frontend with visualization and text explanation. I decided to use Google AI (Antigravity with gemini) to build this application. Prize Categories I am applying for the Google AI (Gemini, Antigravity) and Snowflake tracks. Team Submissions: Shashi Gharti @shashigharti
There is a kind of loneliness that does not always announce itself. It can be quiet. Heavy. Hidden behind a smile. It can make someone feel as though no one truly understands what they are carrying. Dear Stranger was created for those moments. It is a place where someone can pause. Breathe. Read. Feel less alone. And maybe, just maybe, carry a little more hope than they came with. This is not just a project to me. It is a quiet promise. A small place I built with my heart. A space where words can travel gently across distance and still carry comfort. I built Dear Stranger because I believe that even the smallest page can hold something powerful: hope, clarity, warmth, and the feeling of being understood. What I Built Dear Stranger is a web experience designed to feel intimate, human, and deeply personal. It is a space where someone can open a page written by a stranger, read something honest, and feel, even for a moment, that they are not alone. The project is built like a book made of feelings. It invites the visitor to step into a calm, reflective experience where words matter more than noise. They can read pages that speak to comfort, strength, peace, and hope. They can save what touches them. They can leave behind their own words for someone else to find one day. It was never meant to be just another website. It was meant to feel like a page that was waiting for you. Demo The experience is best felt by opening it and letting it meet you where you are. It is meant to be soft, reflective, and quietly powerful. Dear Stranger - this is for you. Code The project is built with Next.js and designed as a personal, story-like interface where emotion is part of the experience. The structure allows users to move through a reading journey, interact with meaningful content, and leave behind something sincere. Konarksharma13 / Dear-Stranger Dear Stranger — A Page for You This website was never meant to be just another page on the internet. It is a quiet place made for the hea
What I Built Overgrowth grows a living, breathing generative tree out of a GitHub username — a portrait of how a person builds, drawn from every repo, language, star and late-night push. Type a name. Watch a few seconds of growth. Meet the tree you've been feeding for years without knowing it. Then the tree does something I didn't expect to love this much: it writes you a short poem about yourself — a little lantern-carrying wanderer walks in under the canopy to deliver it — and reads it to you out loud. And because passion is also rivalry: hit ⚔ vs and grow two trees side by side — you and a friend, stat face-off between them, one shareable link. The challenge said passion — rivalries, fandom, the World Cup. But the line that got me was "the love that fuels late-night side projects." That love already has a data trail; GitHub just renders it as the least romantic thing imaginable — a grid of flat green squares. I wanted the same history to grow something that looks alive . The emotional distance between "a chart of my commits" and "a tree my commits have visibly been feeding" is the entire project. And it's honest. Your abandoned repos are right there on the tree — bare, grey, leafless. Every builder has them. The tree doesn't hide its scars, and that's what makes it a portrait instead of a decoration. Demo 👉 Grow yours: https://overgrowth-one.vercel.app Two trees I met this weekend, same API, opposite souls: (screenshot: torvalds — a moonlit monolingual C giant, 250k-star blossoms, bare dead limbs, leaning into the night) (screenshot: a polyglot — dense multicolored canopy in real linguist colors) My favorite reading it produced, for a tree grown from 15 years of C: "Fed by 15 years of C — leaning into the late hours — 250,742 stars in blossom, 2 scars it doesn't hide." Code https://github.com/ayushbharadva/overgrowth — built entirely within the challenge window (see commit timestamps), AI-assisted with Claude Code, as the rules allow. How I Built It How behavior
This is a submission for Weekend Challenge: Passion Edition What I Built RivalRy is a passion tracker for football rivalries. Fans can log every match against their biggest rivals — win, loss, or draw — rate how intense it felt, and write down the moment as it happened. Over time, it builds a Timeline of every battle and a "Passion Card": a shareable stat card showing total battles, win/loss/draw tally, an overall Passion Rating out of 10, and your single most intense moment — narrated aloud by an AI hype announcer. Passion isn't just about the big clásicos — it's every derby, every gutting loss, every last-minute comeback that stays with you. RivalRy lets you bank that feeling instead of letting it fade, whether it's Real Madrid vs Barcelona, Argentina vs Brazil, or a World Cup 2026 group-stage upset. Demo Youtube demo link- https://youtu.be/6WiRpMUcmGk Live app:- https://rivalryweb.lovable.app/ Code https://github.com/arjunpratapdas/rivalry-pulse-logger How I Built It RivalRy is built with React, Vite, and Tailwind CSS, using browser localStorage to keep every rivalry entry persisted with zero backend setup — fast to build, fast to use. The standout feature is the "Narrate My Rivalry" button on the Passion Card, powered by the ElevenLabs Text to Speech API . When clicked, the app generates a short hype-announcer-style summary of the rivalry's stats and most intense moment, sends it to ElevenLabs, and plays back a natural AI voice narrating it — turning a stat card into something that actually feels like a stadium announcer hyping up your rivalry. One honest note: ElevenLabs free-tier credits are limited, and if they run out, the app gracefully falls back to the browser's built-in speech synthesis with a clear on-screen message, so the feature never breaks — it just degrades gracefully. Prize Categories Submitting for Best Use of ElevenLabs — the AI narration is central to the Passion Card experience, not a bolted-on extra.
Most people think building an AI voice agent means writing a clever prompt. I build these for a living, and I can tell you the prompt is maybe an hour of the work. The other week disappears into two places: wiring up everything the agent touches, and testing it against the twenty ways a real caller will break it. So I built a pipeline that points one AI coding tool at each of those problems. Claude Code generates and wires the agent from a spec. Comet, an AI browser automation tool, runs it through dozens of messy call scenarios before a human ever picks up the phone. This post is how that loop actually works, and where it still needs me. Why the build loop is slow (and it is not the prompt) When you picture building a voice agent, you picture the prompt. That is the easy part. The slow part is everything around it. A production agent for, say, a car garage is not one artifact. It is a conversation flow, a set of custom functions that hit your automation layer, calendar and CRM wiring, a telephony number with A2P registration, and a pile of edge-case handling that only shows up when someone calls in angry with a dog barking in the background. The reason it is slow is not typing. It is the round trips. You build a version, you call it, it fumbles when the caller interrupts or asks something off-script, you fix one thing, you call it again. Each loop is a few minutes of manual dialing and listening. Multiply that by the fifty scenarios a real agent needs to survive and you have burned a week. The pipeline exists to kill those round trips. Half one: Claude Code builds the agent from a spec The first insight is that most of what goes into a voice agent is structured and repetitive, which is exactly what an AI coding tool is good at. I do not hand-write every custom function and every n8n node from scratch for each new client. I write a spec, and I let Claude Code turn that spec into concrete artifacts. The spec is a plain description of the vertical and the business: wh