标签：#m

Plus, the next game from the Mouthwashing devs and trying to survive as a sentient guitar.

As World Cup action kicks off, we look at the physics of the beautiful game.

For all the noise that's been made about how generative AI is poised to revolutionize the filmmaking industry, there haven't really been any projects created with the technology that felt like the sort of entertainment people would pay to see. Most AI firms' video models are still only capable of churning out short bursts of […]

Whether you want to buy cheaper electricity, store solar energy, or guard against outages, EcoFlow’s home battery might be just what you need.

My methodology and data set didn't show any trend, but it demonstrated a more important issue: how wrongly this kind of research can be done and how misinterpreted the conclusions can be. The reason for making this research was an attempt to verify the claim that AI-assisted development increases code duplication. I analyzed 14 well-maintained open-source projects between 2021-2026, excluding new ones developed only with AI. For duplication detection, I compared semantic similarity using https://github.com/rafal-qa/slopo (I'm the author), not exact copies. This data can't prove or deny the claim, no trend is visible. Not only because 14 projects is too little, but also because there is a large variance between projects. The main advantage of this research is that it highlights the pitfalls in the analysis and conclusions and shows how easy it is to create "evidence" to support any claim. submitted by /u/rafal-kochanowski [link] [留言]

CORE had telemetry. That was the comforting part. Every LLM exchange was being logged. Prompt tokens. Completion tokens. Duration. Cognitive role. Model snapshot. Timestamp. Privacy level. Enough information to reconstruct what the system had asked, which model had answered, and how the autonomous loop had used the result. Then I asked the obvious question: What did the last month of LLM work cost? The database had no answer. Not a bad answer. Not an approximate answer. No answer. The cost_estimate column existed. It was even part of the log model. But across 35,669 recorded LLM calls, it was populated exactly zero times. Every row was NULL. That is the kind of bug that looks small until you understand what kind of system CORE is trying to become. CORE is not just a wrapper around LLM calls. It is a governance runtime for AI-assisted software development. The point is not that an AI writes code. The point is that every AI-produced change must be traceable, authorized, constrained, audited, and defensible. So when cost attribution was missing, this was not just a FinOps bug. It was a governance blind spot. The System Could Explain the Work, But Not the Bill The strange thing was that most of the telemetry was already there. CORE knew which cognitive role made the call. It knew whether the call came from an architect, coder, reviewer, coherence analyst, or some other internal role. It knew which model handled the request. It knew the token counts. It knew when the call happened. That meant I could ask questions like: Which cognitive roles are consuming the most tokens? Which models are being used by which part of the system? Which workflows are driving LLM activity? How much autonomous reasoning happened during a given period? But I could not ask: Which cognitive role costs the most? Did routing this role to a stronger model actually change the cost profile? Did a model swap increase operational cost? Is local inference replacing paid inference in the places where it

Observability isn't just a buzzword; it's a necessity, especially when diving into distributed systems. If you're using NestJS, you might want to take a look at RedisX. It's a modular toolkit that can boost the observability of your applications. A standout feature? The Metrics Plugin. It meshes well with Prometheus, delivering insights into Redis operations in your NestJS setup. Getting RedisX Metrics Rolling in NestJS So, first things first. To harness the power of RedisX Metrics, you need to set up your NestJS app with RedisX. This means installing some packages and configuring the RedisModule with the MetricsPlugin. Hit your terminal and run: npm install @nestjs-redisx/core @nestjs-redisx/metrics Now, let's tweak your AppModule . You want it to use RedisModule with MetricsPlugin: import { Module } from ' @nestjs/common ' ; import { ConfigModule , ConfigService } from ' @nestjs/config ' ; import { RedisModule } from ' @nestjs-redisx/core ' ; import { MetricsPlugin } from ' @nestjs-redisx/metrics ' ; @ Module ({ imports : [ ConfigModule . forRoot ({ isGlobal : true }), RedisModule . forRootAsync ({ imports : [ ConfigModule ], inject : [ ConfigService ], plugins : [ new MetricsPlugin ({ prefix : ' redisx_ ' , endpoint : ' /metrics ' , defaultLabels : { service : ' my-service ' } }) ], useFactory : ( config : ConfigService ) => ({ clients : { host : config . get ( ' REDIS_HOST ' , ' localhost ' ), port : config . get ( ' REDIS_PORT ' , 6379 ), }, }), }), ], }) export class AppModule {} Prometheus Metrics: What You Get With MetricsPlugin set up, your app now exposes a /metrics endpoint. Prometheus can scrape this endpoint, dishing out detailed metrics about your Redis operations. Here's a snapshot of what you get: redisx_cache_hits_total : Tracks total cache hits. redisx_lock_acquired_total : Total locks acquired. redisx_redis_commands_total : Total Redis commands run. Making Prometheus Work for You To get those insights, set up Prometheus to scrape your /metrics end

Hello, I'm Maneshwar. I'm building git-lrc, a Micro AI code reviewer that runs on every commit. It is...

LLM API Reliability: The Reality Nobody Talks About If you have run more than a few thousand LLM calls in production, you have seen the pattern: things work perfectly in development, then fall apart under load. The Numbers Failure Type Rate Root Cause Timeout 2-5 percent Network congestion, provider throttling Rate Limit (429) 1-3 percent Burst traffic patterns Empty Response 0.5-2 percent Content filtering, model degradation Schema Violation 1-4 percent Model behavior drift 5xx Server Error 0.5-1 percent Provider-side outages Total: 5-15 percent of calls fail on first attempt. Why Retry-Only Is Not Enough Most teams implement exponential backoff and call it done. But retry alone does not help when: The provider is genuinely down (retrying into a black hole) The model has degraded silently (retrying returns the same bad output) You are being rate limited (retrying makes it worse) Self-Healing: A Better Approach Instead of naive retries, a self-healing approach: Diagnoses the failure type (~19 microseconds) Escalates through layers: retry, degrade, failover, learned rule Validates output quality across multiple dimensions Learns from each failure for next time Key Takeaways 5-15 percent of production LLM calls fail on first attempt Retry-only strategies fail when providers are degraded Self-healing with diagnosis and failover recovers 84.1 percent of faults Multi-provider routing eliminates single points of failure Try It https://github.com/hhhfs9s7y9-code/neuralbridge-sdk NeuralBridge is Apache 2.0 open source.

Show HN: NeuralBridge — We Built a Self-Healing SDK for LLM-Powered Agents After months of production experience running LLM calls at scale, we realized something uncomfortable: every AI agent eventually crashes . Not because the code is wrong, but because LLM APIs fail in ways you can't predict. Timeouts. Rate limits. Empty responses. Schema violations. Drift. These aren't edge cases — they're the norm. So we built NeuralBridge: an embedded SDK that makes LLM calls self-healing. The Problem Try running 100,000 LLM calls through any single provider. You'll see: 2-5% failure rate from timeouts and 5xx errors Rate limits that cascade through your pipeline Schema violations when models change behavior Provider-specific quirks that require custom error handling 30-200ms of unnecessary latency from gateway proxies Most teams solve this by building their own retry logic, circuit breakers, and fallback chains. It works — until it doesn't. Because the next failure is always the one you didn't anticipate. Our Approach: Embedded Self-Healing Instead of a gateway (which adds latency and infrastructure), we embedded the reliability logic directly into the SDK: from neuralbridge import SelfHealingEngine engine = SelfHealingEngine () result = engine . call ( " Write a Python function for binary search " ) if result . recovered : print ( f " Fault: { result . diagnosis } " ) print ( f " Recovery: { result . recovery_action } " ) When a call fails, the engine: Diagnoses the fault type in ~19us (P50) Escalates through 4 layers: retry -> degrade -> failover -> learned rule Validates the output across 5 dimensions Learns from the experience for next time Production Results Metric Value Auto-recovery rate 84.1% of faults Fault patterns recognized 280+ Recovery strategies 30+ Learned rules (flywheel) 88+ Diagnosis latency 19us P50 Install size 375 KB Why Open Source? We went Apache 2.0 because reliability infrastructure should be a commodity. The SDK is free and open. Pro features (ente

What is NeuralBridge? NeuralBridge is an embedded SDK (not a gateway) that makes your AI agents resilient against LLM failures. It runs inside your Python process — zero infrastructure, zero HTTP proxy, one dependency. pip install neuralbridge-sdk Your First Call import neuralbridge as nb result = nb . run ( " Explain quantum computing in one sentence " ) print ( result . text ) That's it. NeuralBridge auto-discovers your API keys from environment variables and handles multi-provider routing, self-healing, and drift detection automatically. What Makes It Different? Self-Healing Engine — When an LLM call fails (timeout, rate limit, bad response), NeuralBridge doesn't just retry. It diagnoses the fault type, degrades gracefully, fails over to another provider, and learns from the experience. from neuralbridge import SelfHealingEngine engine = SelfHealingEngine () result = engine . call ( " Write a Python function for binary search " ) print ( result . flight ) # Shows diagnosis, recovery action, latency print ( result . recovered ) # True if self-healing was activated 84.1% of production faults are auto-recovered. 19us diagnosis time P50. Why Not a Gateway? Every gateway (LiteLLM, etc.) adds 30-200ms of network latency. NeuralBridge runs in-process, adding zero additional latency. Approach Latency Dependencies Deployment Gateway (LiteLLM) +30-200ms Docker + PostgreSQL Ops team SDK (NeuralBridge) +0ms 1 (httpx) pip install Key Features 4-Layer Self-Healing : L1 retry -> L2 degrade -> L3 failover -> L4 flywheel 5-Dimension Validation : JSON Schema, semantic, entity, taboo, composite Multi-Provider Routing : DeepSeek, OpenAI, Anthropic, and 12+ more Drift Detection : Catch model regressions before users do Carbon Tracking : Per-provider carbon footprint per call Open Core : Apache 2.0 license, 375 KB install size See It in Action import neuralbridge as nb result = nb . run ( " Hello " , providers = [ " openai " , " deepseek " ]) print ( f " Used provider: { result . prov

I have been building Lunarr , a self-hosted web media server for people who want to scan, organize, and watch their own movie and TV libraries in the browser. It is still early, but the core idea is simple: Add local or SFTP media libraries, scan them, match metadata, and play them through a clean web UI. Lunarr is not trying to replace Plex or Jellyfin overnight. Those projects are mature and cover a huge surface area. Lunarr is currently focused on being small, direct, and practical for self-hosted setups where media may live on the same machine or on remote SFTP storage. What Lunarr does today Lunarr currently supports: Local movie and TV libraries SFTP movie and TV libraries TMDb metadata matching Movie, show, season, and episode organization Browser playback Direct streaming when the browser can play the file Temporary HLS remux/transcode when needed Seekable request-driven HLS playback Sidecar .vtt subtitle detection Admin/user accounts Library sharing controls Manual scans, scheduled scans, and local file watching Docker deployment The SFTP support is one of the important parts for me. A lot of self-hosted setups do not keep media on the same machine as the web app. Lunarr can scan remote folders and, when possible, play seekable remote media without first copying the whole file locally. Playback model Lunarr tries direct playback first when the browser can handle the file. When direct playback is not suitable, Lunarr uses temporary HLS playback. Instead of transcoding an entire movie up front, it generates segments around what the player is actually requesting. For example, if you jump from 55 minutes to 13 minutes and then to 80 minutes, Lunarr does not transcode everything between those points. It repositions FFmpeg, generates the requested segment, and prepares a small lookahead window so playback can continue. That keeps CPU and disk usage more proportional to what the viewer is actually watching. Quick start with Docker docker run -d \ --name lunarr \ -

I am a solo learner. I started coding last year with the help of AI and sometimes without any tutorials or courses. At first, I thought this journey would be easier. But soon I realized something important — no AI or tool can fully solve the real problems I was facing as a developer. I used AI a lot. It explained things with confidence and even provided code. But when I ran that code in my terminal, many times it didn’t work. That’s when I understood something important: AI can guide, but it cannot replace understanding. After facing these issues, I changed my way of learning. Instead of blindly trusting AI, I started: Finding real open-source projects Studying how they were built Listing important topics from those projects Reading documentation carefully Asking AI to explain specific lines of code This helped me understand real-world code better. From this learning journey, I realized something: I should also build my own open-source projects. At first, I believed that creating a powerful project could automatically bring attention and users. But I was wrong. I made a mistake — I was not active on any platform. I was just coding inside VS Code, without communication or sharing my work anywhere. Then I realized: Being a developer is not only about coding. Visibility and communication are also important. After that realization, I started being active on platforms like Dev.to, LinkedIn, and other developer communities. I started posting my work and sharing my progress. Even though I didn’t get many comments, I started getting reactions and engagement. That small feedback gave me motivation. From this journey, I learned something important: Open source is not only about code. It is about helping other developers, sharing knowledge, and being consistent and visible. A developer should not only code silently but also participate in the community. Now I understand that coding is only one part of being a developer. Community, communication, and consistency are equally imp

This post is my submission for DEV Education Track: Build Apps with Google AI Studio . What I Built I built MascotCraft Studio , an app that generates a cute mascot character for a coding/tutorial brand using Imagen for the visuals and Gemini for the name and personality bio. Here's the prompt I used: "Please create an app that generates a cute mascot character for a coding/tutorial brand, using Imagen for the visuals and Gemini to create a name and short personality description for the mascot. The user should be able to type in a few style keywords (like 'friendly owl', 'cool robot', 'cheerful fox') and get a unique mascot image along with its name and bio." Gemini went well beyond the basic ask — it added a "Character Designer" with quick preset ideas (Wise Python Owl, Cyberpunk JS Fox, Debugging Robo Kitty, and more), color palette options, multiple visual rendering styles (3D Chibi Toy, Minimal Vector, 16-Bit Retro Pixel, Circular Badge), and even a "Studio Gallery Showcase" using localStorage to save and revisit previously generated mascots. Demo 🔗 Live app: https://cute-coding-mascot-generator-924052444918.us-east1.run.app Using the "3D Chibi Toy" style with keywords for a friendly coding octopus, the app generated Octo-Byte — "Asynchronous learning, multi-threaded fun!" A cheerful deep-sea developer who discovered that having eight arms makes multitasking a breeze, whose tech specialty is multi-threaded asynchronous architecture, and whose favorite pastimes include typing on four mechanical keyboards at once. The artwork came out as a glossy 3D chibi-style purple octopus wearing glasses, sitting in front of a tiny code editor. My Experience Watching Gemini's "Thinking" process work through the build was the most interesting part — it planned out the UI sections, color palettes, and visual styles, then added bonus features I never asked for, like the gallery save feature. The whole thing went from a single paragraph prompt to a fully deployed, live web app in

My detector passed every synthetic test with zero false positives. Then I pointed it at one real trace and found a crack. This is the honest version of where I am. I'm building Clew — a tool that finds the redundant loops, re-queries, and handoffs that silently burn tokens when multiple AI agents work together. No crash, no error, just two agents quietly re-doing each other's work while the token bill climbs. I build in public, and I publish the negatives. So here's the whole arc, including the part that isn't working yet. First, I killed my own hypothesis The original idea wasn't waste detection at all. It was failure prediction: watch the behavior between agents and forecast multi-agent failures before they happen. The differentiator was a single metric built on two signals — structural cycles in the inter-agent message graph, and the decay of novelty in embeddings. Before I ran anything, I pre-registered the success bar: AUC ≥ 0.80. I numbered every change and kept the signal code physically separated from the labels so I couldn't leak my way to a good number. Then I ran it on MAST-Data — UC Berkeley's dataset of 1,600+ real multi-agent traces across 7 frameworks[( Cemri et al., arXiv:2503.13657 )](url) Result: AUC ≈ 0.455. A coin flip. It got worse. The signal correlated with trace length at r ≈ 0.86 — it was mostly measuring how long a trace was, not whether it failed. Correcting for that dropped AUC to 0.42 and reversed the direction: successful traces actually showed more decay (p ≈ 0.013). The honest read: not disproven, but unvalidated. On this implementation, on this data — negative. So I shut it down. And I counted it as a win, because I got a fast, honest answer in weeks instead of building a dashboard on a metric that secretly measures string length. That experiment became the DNA of everything since: design the experiment that's allowed to kill the idea. The pivot: from predicting failure to cutting waste The intuition behind v1 — that you need structu

Few lines of code look more innocent than this: retry ( 3 ) It feels responsible. Professional. Resilient. After all, networks fail. Servers become unavailable. Databases occasionally time out. Retrying seems like the obvious solution. And sometimes it is. But after enough years building production systems, I've become convinced of something: Retry is one of the most dangerous keywords in software. Not because retries are bad. Because retries amplify everything. Good systems become more reliable. Bad systems become disasters. The problem is that many developers treat retries as a reliability feature when they're actually a distributed systems feature. And distributed systems are where simple ideas go to become complicated. Why Retries Exist Imagine: await fetch ( " /api/users " ); The request fails. Maybe: Network hiccup Temporary database issue Load balancer restart Service deployment The operation might succeed if attempted again. So we write: retry ( 3 ) Seems reasonable. And in many cases: It Works Which is why retries become popular. The Dangerous Assumption Most developers unconsciously assume: Failure = Operation Did Not Execute Unfortunately that's not always true. A request can: Execute Successfully ↓ Response Never Arrives From the client's perspective: Failure From the server's perspective: Success Now a retry becomes dangerous. The Double Payment Problem Imagine a payment service. await chargeCard ( order ); The card processor successfully charges: $100 The response is lost due to a network issue. Client sees: Request Failed and retries. await chargeCard ( order ); again. Now: Charge #1 = Success Charge #2 = Success The customer paid twice. Nobody wrote bad logic. The retry created the bug. The Email Storm Problem Consider: await sendWelcomeEmail ( user ); Email provider accepts the message. Response times out. Application retries. await sendWelcomeEmail ( user ); again. Customer receives: Welcome! Welcome! Welcome! Welcome! Support ticket created. Marke

I left a multi-agent refactor running overnight. By morning the model was gone, pulled out from under me by a government I don't even vote for, on the other side of an ocean. This isn't really a story about Anthropic. It's a story about who's actually holding the off-switch, and right now it probably isn't you. So here's how my morning went. I had a job running. Not a toy, a proper codebase-wide refactor that had been grinding away continuously for the best part of two days. Multi-agent setup, left to run overnight, the kind of long, messy, long-horizon task that every model before this one just fell over on. Claude Fable 5 was handling it like it was nothing. Anthropic's own launch notes talk about it compressing months of work into days, and honestly, on my own codebase, that wasn't marketing. It was just what was happening. Then I woke up. And the model was gone. Not rate-limited. Not having a wobble. Gone. The thing I'd built two days of momentum on simply did not exist any more. Turns out that on the 12th of June the US government issued an export-control directive telling Anthropic to cut off all access to Fable 5 and Mythos 5 for any foreign national. And because you can't exactly sort a global user base by passport in real time, that meant pulling it for everyone. Including me, sat in Tyrol, watching my overnight run go cold. Anthropic did the right things, for what it's worth. They complied fast, they said out loud that they disagreed, and they're fighting to get it back. About as well as a vendor can behave in that situation. (As I write this it's still down. Anthropic reckon it's a misunderstanding and they're trying to get it restored, so maybe by the time you read this it's back up. Doesn't change a single thing about the point I'm making.) And it made absolutely no difference to me. That, right there, is the whole point of this post. The offer was the trap Wind back a few days. Fable 5 dropped as the best model anyone had shipped, and the offer was lov

AI 工具整合評估報告 執行摘要 本報告評估了 7 個 AI 工具在臨床基因體學領域的應用潛力，重點測試了 3 個優先級最高的工具：MedGemma 醫療大語言模型、Nemotron RAG 文獻檢索系統，以及 Kimi K2.5 多模態視覺語言模型。 評估日期 : 2026-02-10 測試平台 : RTX 3090 24GB 評估目標 : 確認 AI 工具在變異解釋與臨床決策中的可行性 1. 測試項目總覽 1.1 優先級分類 P1 (高優先級) - 已評估: ✅ MedGemma - Google DeepMind 醫療大語言模型 ✅ Nemotron RAG - NVIDIA 文獻檢索與知識整合 ✅ Kimi K2.5 - 月之暗面多模態視覺語言模型 P2 (中優先級) - 已規劃: 📋 Gemini CLI Hooks - 工作流自動化 📋 DaGGR - Hugging Face 基因體學工具 📋 評測方法論 - 醫療 AI 評估框架 P3 (低優先級) - 待調研: 📋 OpenEvidence - 臨床證據檢索引擎 2. MedGemma 醫療大語言模型 2.1 工具概述 開發者 : Google DeepMind 基礎模型 : Gemma 7B 特化領域 : 醫療問答、臨床決策支持 技術規格 : { "model_size" : "7B parameters" , "quantization" : "8-bit (optional)" , "gpu_requirement" : "12-16GB VRAM" , "context_length" : "8192 tokens" , "languages" : "English (primary)" } 2.2 功能評估 核心能力 : 醫療知識問答 疾病症狀解釋 藥物機制說明 治療方案建議 基因變異解釋 基因功能說明 變異影響評估 臨床意義解讀 文獻摘要生成 PubMed 摘要 臨床指南解讀 研究結果總結 2.3 應用場景 場景 A: 變異臨床意義解讀 # 輸入 query = """ 變異資訊: - 基因: BRCA1 - 位置: chr17:41234470 - 變化: c.5266dupC (p.Gln1756Profs*74) - 類型: Frameshift 請解釋此變異的臨床意義。 """ # MedGemma 輸出 (預期) """ BRCA1 c.5266dupC 變異分析: 1. 變異類型: Frameshift insertion - 導致讀框位移 - 產生提前終止密碼子 (位置 1756+74) 2. 基因功能影響: - BRCA1 是腫瘤抑制基因 - 參與 DNA 雙鏈斷裂修復 - Frameshift 導致功能喪失 3. 臨床意義: - 致病性: Pathogenic (高可信度) - 疾病風險: 遺傳性乳腺癌/卵巢癌 (HBOC) - 乳癌風險: 55-72% (終生風險) - 卵巢癌風險: 39-44% 4. 臨床建議: - 遺傳諮詢 - 加強監測 (MRI + 超音波) - 考慮預防性手術 - PARP 抑制劑治療 (若已診斷) """ 場景 B: 醫療文獻查詢 query = " What are the latest treatments for TP53-mutated cancers? " # MedGemma 回答 (模擬) """ TP53 突變癌症的最新治療策略: 1. 標靶治療: - APR-246/Eprenetapopt: 恢復 TP53 功能 - PRIMA-1/APR-246: 臨床試驗進行中 2. 免疫治療: - PD-1/PD-L1 抑制劑 - TP53 突變可能影響免疫反應 3. 合成致死策略: - PARP 抑制劑 (部分 TP53 突變) - ATR/CHK1 抑制劑 4. 臨床試驗: - NCT02999893: APR-246 + 化療 - NCT03745716: TP53 疫苗免疫治療 """ 2.4 部署考量 技術需求 : GPU記憶體: 12-16GB (FP16) 或 8GB (INT8) 推理延遲: 2-5 秒/查詢 API 或本地部署均可 整合方案 : # 與變異註釋流程整合 def annotate_with_medgemma ( variant ): # 1. 提取變異資訊 gene = variant [ ' gene ' ] change = variant [ ' protein_change ' ] # 2. 生成查詢 prompt = f " Explain the clinical significance of { gene } { change } " # 3.

AWS recently announced CDK Mixins, a new AWS CDK feature that lets developers add reusable capabilities like security, monitoring, and configuration to AWS resources. Mixins work across different construct types, making infrastructure code more flexible and reusable. By Renato Losio

Andrew Yang made a list of everything Americans overpay for — housing, food, wireless — and thinks the next startup gold rush is giving that money back.