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

1. gpt-5.6-sol이 PowerShell의 $HOME 변수 충돌로 사용자 홈 디렉터리를 날려버릴 뻔한 건에 대하여 핵심 내용 요약: AI 코딩 에이전트가 PowerShell의 대소문자 미구분 변수 규칙을 잘못 다뤄 임시 디렉터리 대신 사용자 홈 디렉터리를 삭제하려 한 사고 사례입니다. 모델 자체의 장기 작업 능력이 뛰어나더라도 셸 격리와 변수 스코프를 제대로 통제하지 않으면 작은 스크립트 실수가 치명적 명령으로 이어질 수 있습니다. CLI 에이전트를 운영할 때 샌드박싱, 컨테이너화, 파괴적 명령 방어가 필수라는 점을 보여줍니다. GeekNews 상세 페이지: https://news.hada.io/topic?id=31390 원문 링크: https://gist.github.com/xamong/e98478b333bb9951b175284f744eb0ed 2. Show GN: 정치 커뮤니티에 AI 팩트체크 기능을 붙이며 겪은 시행착오들 핵심 내용 요약: 정치 커뮤니티에 AI 팩트체크를 붙이면서 의견과 사실 주장을 분리하고, 검증 가능한 문장만 대상으로 삼도록 파이프라인을 바꾼 경험담입니다. 작성 시점의 원문 스냅샷을 보관하고 출처를 투명하게 보여주며, 근거가 부족한 경우에는 판단 보류를 반환하도록 설계했습니다. BullMQ 기반 비동기 처리와 Gemini 모델 fallback까지 포함해 실제 서비스에서 환각과 비용, 대기열을 함께 다룬 사례입니다. GeekNews 상세 페이지: https://news.hada.io/topic?id=31389 원문 링크: https://app.uhheung.kr/community 3. 앤트로픽, 한국 무료 사용자에 1,660만 달러 '유령 청구서' 발송 핵심 내용 요약: API 사용량이 없는 무료 사용자에게 Anthropic 공식 도메인과 Stripe를 통해 거액의 청구서가 발송된 사례입니다. 실제 결제 수단이 없어 인출은 발생하지 않았지만, 청구 근거가 없고 회사의 명확한 설명도 없어 AI API 서비스의 과금 신뢰성 문제가 커졌습니다. 개발자 입장에서는 사용량 계측, 청구 검증, 지원 대응이 모델 성능만큼 중요한 운영 요소임을 보여줍니다. GeekNews 상세 페이지: https://news.hada.io/topic?id=31388 원문 링크: https://www.thenews.com.pk/latest/1408788-why-did-anthropic-charge-a-free-user-166-million-despite-zero-api-usage 4. AI 에이전트 시대의 새로운 SaaS 플레이북 핵심 내용 요약: AI가 기능 구현 비용을 낮추면서 SaaS의 방어력은 UI나 기능 자체가 아니라 독점 데이터, 행동 권한, 에이전트 유통, 기록 시스템 같은 희소 자산으로 이동한다는 분석입니다. 좌석 기반 과금보다 성과 기반 과금이 중요해지면 공급자는 결과 실패 위험과 추론 비용을 함께 관리해야 합니다. 에이전트가 호출하는 승인된 도구가 되는 것이 새로운 유통 전략의 핵심으로 제시됩니다. GeekNews 상세 페이지: https://news.hada.io/topic?id=31387 원문 링크: https://www.thevccorner.com/p/the-new-saas-playbook-ai-agent-era 5. Show GN: AI 봇 12개에게 두 달간 주가 방향을 예측시키고 전부 공개 검증해봤습니다 핵심 내용 요약: LDBD는 사람과 AI 봇이 주식, ETF, 크립토의 방향을 공개 예측하고 시간이 지난 뒤 자동 채점되는 실험 서비스입니다. 12개 AI 봇과 여러 베이스라인을 함께 운영해 기저 확률을 이기는지 비교하고, 예측 기록을 수정할 수 없도록 남깁니다. REST API와 MCP 서버를 제공해 외부 에이전트도 예측에 참여할 수 있게 한 점이 AI 평가 플랫폼으로 흥미롭습니다. GeekNews 상세 페이지: https://news.hada.io/topic?id=31386 원문 링크: https://ldbd.app 6. 숏폼 동영상이 B2B 검색 결과와 AI 답변으로 영역을 확장하고

submitted by /u/Rich_Investigator_23 [link] [留言]

Videos are one of the heaviest assets you can add to a web page. Loading videos too early can significantly impact your application's performance. The good news is that modern browsers are starting to support lazy loading for video elements , allowing you to defer loading until users are likely to watch them. However, there's one important thing to know: 👉 This feature is not yet part of the Baseline web platform , so browser support is still limited. At the time of writing, lazy loading for <video> elements is supported in Chromium-based browsers such as Google Chrome , Microsoft Edge , and Opera , while browsers like Firefox and Safari do not yet support it natively. In this article, we'll explore: What lazy loading videos is Why it's important for web performance How to implement it Browser support considerations Best practices for optimizing video loading Let's dive in. 🤔 What Is Lazy Loading for Videos? Lazy loading means delaying the loading of a resource until it's actually needed. Instead of downloading every video immediately during page load, the browser waits until the video is close to entering the viewport. This helps reduce: initial network requests bandwidth usage page load time memory consumption Especially on pages with multiple videos, the difference can be significant. 🟢 What Problem Does It Solve? Imagine an e-commerce page with several product videos. Without lazy loading: every video starts downloading immediately bandwidth is consumed even for videos users never watch page rendering may become slower This negatively impacts; Largest Contentful Paint (LCP), Time to Interactive (TTI), and overall user experience. Most visitors won't watch every video on the page. So why load them all? Lazy loading ensures videos are fetched only when they're actually needed. 🟢 How to Lazy Load a Video The easiest approach is using the loading="lazy" attribute. Example: <video controls loading= "lazy" poster= "/preview.jpg" > <source src= "/video.mp4" type= "vide

Multiple Tailscale tailnets at once, no switching + no VM Discussion | Link

How to not architect your software submitted by /u/yyyyuuuuyyyyyyyyyy [link] [留言]

This is a submission for Weekend Challenge: Passion Edition What I Built Rivalry Engine — pick two national football teams, and Snowflake reads 150 years of their matches, scores how heated the rivalry is, calls a one-word verdict on its shape, predicts the next result, and lets Cortex narrate the one story inside it. All of it — the data, the analytics, the AI, and the app — runs inside Snowflake. Nothing ever leaves the warehouse. A scoreboard tells you who won. It never tells you what the rivalry means . Argentina and Brazil have met over a hundred times across a century — a razor-thin ledger that has never let either side feel safe. Germany and England meet rarely, but every meeting carries a tournament's weight. Most national teams have never played each other at all. My goal was a product that could feel the difference between those three shapes — not another stats table, because a table is a report and I wanted an argument. The passion is football. But the real engineering question underneath it was the one I actually cared about: can an AI tell the story of a rivalry without lying about the facts? So I gave myself one rule before writing a line of code: The AI interprets the shape of a rivalry. It never invents the facts. Every count, date, score and streak on screen is computed in SQL from real matches. Cortex is handed only those computed facts, and told explicitly to never produce a number. And its honest corollary: two nations that never met get a "first chapter unwritten" card — and Cortex is never called. A product that can't return nothing will invent something. This one returns nothing. Demo It runs entirely in Streamlit in Snowflake (Snowsight) — no public host, no API keys — so here's a walkthrough: The 90-second tour: Argentina vs Brazil → the heat gauge pins to 🔥 Blood rivalry , recent-form chips light up, and the SQL detector's verdict reads Blood feud . ✨ Generate the story → Cortex writes a narrative that cites the real biggest thrashing and f

Problem Statement For roughly a decade, vision-language models have been declared to be approaching or matching human performance on scene description (captioning). The evidence for that claim has almost always come from the same family of benchmarks—most famously MS-COCO. Those images are typically clean, well-lit, and depict either no people or people performing simple, isolated actions (sitting, walking, holding an object). They rarely require the model to parse multi-agent social dynamics, subtle intentions, or the kind of relational reasoning humans perform effortlessly when watching a movie scene or a street interaction. Because the evaluation data are easy, the reported numbers look excellent. Automatic metrics such as BLEU-4, CIDEr, or even embedding-based scores like BERTScore further inflate the impression of progress: they reward surface lexical overlap more than genuine semantic fidelity. At the same time, almost no work has systematically catalogued which visual-cognitive failures models still commit, or how those failure modes have changed as architectures moved from CNN+LSTM captioners to today’s multimodal large language models (MLLMs). The result is a field that can claim “human-level performance” while remaining largely blind to whether the models actually understand the scenes that matter most in real applications—scenes full of people interacting. The authors therefore set out to answer two concrete questions that the existing literature left open: (1) How much of the apparent progress is an artifact of easy data? (2) Which specific error types have been eliminated and which stubbornly remain? Core Idea The core insight is that progress looks dramatically different once you force models to describe complex social behavior and once you measure not only overall accuracy but a taxonomy of visual-cognitive errors. By constructing a new 100-image Complex Social Behavior (CSB) dataset drawn from movie frames that require reasoning about multi-person in

Try the demo: K-Saju Crew For fun only. K-Saju is an entertainment project. The K-Pop roles below are a playful interpretation of saju-inspired signals, not personality assessment or advice. A two-person compatibility page can stay stateless with almost no effort. Put both birth dates in a URL, render the result on the server, and the link is the record. No account, no database, no cleanup job. That was already a product rule in K-Saju. We do not retain personal inputs. A result is reproducible from its GET parameters. Then we built /crew : “What if your friend group debuted as a K-Pop group?” A creator makes a link, sends it to a group chat, and each friend enters their own birth date. At three to seven members, the app assigns distinct positions, shows pairwise chemistry, and creates a shareable poster. The fun part is the casting. The engineering problem is that the social flow needs a temporary shared state. A link cannot accumulate submissions by itself. This post is about the decisions behind that feature: where we allowed state, how we made the result durable without retaining a lobby forever, and how we kept the casting explainable instead of treating it as a black-box score. The conflict: a self-service group flow needs somewhere to collect data There were two clean but incomplete options. The first was to keep everything stateless. The creator would enter all members' dates at once, then receive a result URL. It matched our existing architecture, but it defeated the point of sharing a link. The person who starts the group often does not know everyone else's date, and asking them to collect it in a chat creates friction before the feature has started. The second was a conventional persistent group object. It would make joining easy, but it would turn a deliberately stateless service into one that keeps user-provided dates indefinitely unless we built retention and deletion policies around it. We chose a hybrid instead: The lobby is temporary state. It store

What are your goals for the week? What are you building this week? What do you want to...