标签：#war

A few weeks ago I wrote about why I built Apiarium after OpenRouter solved one problem for me and I still had four more. The comments on that post ended up shaping a good chunk of what I actually built next, so this is the "here's what changed" follow-up. The interesting part isn't really the features. It's where they came from. Almost everything below started with someone telling me something was annoying, confusing, or missing. So instead of adding things because they looked good on a roadmap, I tried to fix the problems people were actually running into. Multiple API keys, not one shared key for everything The biggest ask came directly from someone using Apiarium in production. They wanted to know which app or feature was actually driving usage, without having to share one API key across everything and lose that signal. So now you can create multiple keys per account: 2 on Free 5 on Starter 10 on Pro You can name them, revoke them individually, and every request is tagged with the key that made it. Credits are still shared across the account, the keys are about visibility, not splitting your balance. // key for your production app fetch ( ' https://api.apiarium.dev/llm ' , { headers : { Authorization : ' Bearer sk-prod-... ' }, ... }) // separate key for a side project // same account, same credits fetch ( ' https://api.apiarium.dev/llm ' , { headers : { Authorization : ' Bearer sk-sideproject-... ' }, ... }) You can also see when each key was last used and filter usage by key in the dashboard. That last part was really the reason I built it. A dashboard that answers "where did my credits go?" The old dashboard was basically a number going down. That wasn't particularly useful. The new dashboard is split into Overview, Usage, API Keys, and Billing. There's a proper date range filter with 7d/30d presets or a custom range, and that same range drives the usage chart, breakdowns, and request logs together. You can break usage down by model and endpoint, so you can ac

Text-to-Speech Is Not a speak() Call The challenge 🧪 If you have ever assumed Text-to-Speech on Android is straightforward, this article is for you. But first, let us test your skills. Think you can make this speak on Android? 🙏 अव्यक्तोऽयमचिन्त्योऽयमविकार्योऽयमुच्यते । "Invisible, beyond thought, unchanging." — Krishna describing the nature of the self. Today is World Sanskrit Day, so the timing is fitting. 🕉️ Try playing it on the plain TextToSpeech API that Google provides — but specifically with a Sanskrit voice. Build a minimal Android app, initialize the TTS engine, set the language to Sanskrit, and call speak() on this string. Chances are it will not speak anything. Not even a single letter would be uttered. 🔇 That is the moment when a developer realizes that TTS is not a simple API call. The twist 🔄 Use a Marathi or Hindi voice instead. Same engine. Same text. Same API call. It plays perfectly. 🗣️ Same engine. Same verse. Different voice. Completely different result. The boundary between "speakable" and "not speakable" is not at the engine level. It is at the voice level within the engine. The Sanskrit voice within Google's TTS engine cannot handle this verse. But the Marathi voice — which shares much of the same Devanagari character set — handles it without issue. This changes how you think about TTS integration. What happened in production 🏭 This is not a theoretical exercise. This is what we actually hit. In Bhagavad Gita, the player screen uses TTS to read verses aloud. The experience is designed to feel like playing a media file: continuous, flowing, uninterrupted. But certain words — especially compound words and special conjunct characters — were being silently skipped. Not errored. Not logged. Just... silent. The engine would skip the entire word if it couldn't speak something in it. So a verse that should take 15 seconds to read would finish in 8. The user would hear a flowing recitation with missing pieces and never know what was lost. 😶 The worst

First of all, I warmly welcome everyone out there in the DEV Community. [Completely open for discussion — drop your thoughts below.] From my perspective, it feels like everyone is racing towards AI/ML. The moment someone says they want to become an AI/ML Engineer, the conversation immediately shifts towards: Python → ML → Deep Learning → LLMs → Latest AI Tools And thinking about it, well, it’s quite understandable too. AI is one of the most exciting areas in technology right now. BUT, I have a question… Why are we starting to treat AI/ML Engineering as something completely different from Software Engineering? I often see people following an extremely narrow path towards AI/ML while completely skipping the fundamentals of Software Engineering. Backend development gets ignored. Databases, networking, operating systems, system design — all of them get ignored. And afterwards: APIs, deployment, testing, distributed systems… All of these seem quite trivial, right? Because the end goal is simply to create or automate something with AI. But it’s quite clear to me that AI can’t possibly live by itself. For any AI model to thrive, we need data. That data needs storage and pipelines. A model needs an application around it. That application needs APIs. Those APIs need backend infrastructure. And now we have an actual system. That system needs to be monitored for bugs, optimized for CPU and memory efficiency, refactored when necessary, maintained over time, and tested against new use cases. So thinking about all of this: How does one even fathom becoming an AI/ML “Engineer” without understanding what they are actually engineering into and working on? Maybe AI/ML Engineering and Software Engineering aren’t two completely different entities. Maybe they are different components of the same system. Now, I’m not saying: “You should become an expert in everything.” Specialization is indeed important. But specialization doesn’t necessarily mean abandoning the fundamentals that the spe

How to combine exponential backoff, circuit breakers, and graceful fallbacks for production-grade agentic workflows. The Bottleneck in Production AI agents are only as reliable as the tools they invoke. When an LLM decides to search the web, scrape a URL, or fetch database records, it depends entirely on network stability. In production, external APIs fail constantly. A sudden surge causes 429 rate limits, a third-party microservice throws a 504 timeout, or a target endpoint goes down entirely. The naive approach—executing raw tool calls directly inside the agent loop—is a ticking time bomb: # The Naive Anti-Pattern: Fragile Tool Execution def execute_agent_tool ( tool_name : str , payload : dict ): # One 500 error here kills the entire multi-step reasoning chain response = requests . post ( f " https://api.service.internal/ { tool_name } " , json = payload ) return response . json () When this call breaks, the unhandled exception crashes the runtime. You lose the entire reasoning graph, waste LLM tokens, and degrade the user experience. The System Architecture: Layered Tool Defense To keep multi-step agents alive, you need a defensive execution pipeline wrapped around every tool. Instead of allowing errors to bubble up and kill the agent, we handle failures across three distinct layers: Exponential Backoff : Mitigate transient network glitches and minor rate spikes by retrying with increasing delays. Circuit Breaker : Detect persistent downtime. If an API fails three times consecutively, trip the breaker to stop sending doomed requests. Graceful Fallbacks & Partial Degradation : When a primary service is down, route the query to a replica, cached store, or lightweight fallback (e.g., cached search index instead of a live browser scrape). [ Agent Core ] │ ▼ ┌───────────────────────────────┐ │ Circuit Breaker Check │ │ (Is Primary Service Up?) │ └──────────────┬────────────────┘ OPEN │ CLOSED (Healthy) ┌───────┴────────┐ ▼ ▼ ┌─────────────┐ ┌─────────────────────────

Hello, I'm Maneshwar, and I'm building LiveReview — a blast-radius aware AI code review built for...

KH4 Companion is a small extension I built: it counts down to Kingdom Hearts IV, puts the days remaining on the toolbar badge, pulls series news and trailers from public feeds, carries a lore compendium, and hides a three-lane rhythm minigame in the popup. It has been on the Chrome Web Store since 19 August. As of this week it is also on addons.mozilla.org , which makes it my first Mozilla listing. I had been putting the port off, because "port" sounds like work. It was not. Same build, same version number, same feature set — what changed was four keys in manifest.json . This is the writeup I wanted to find before I started. The thing nobody tells you first The blocker is not your code. It is that AMO rejects the package before it ever shows you a listing form. So the order of operations is: fix the manifest, get the linter to zero errors, then worry about icons and screenshots and copy. Assets built against a package that cannot upload are wasted. npx addons-linter@latest <extension-dir> is the gate. Run it before you touch anything else. 1. Firefox needs an explicit add-on ID Chrome derives an extension ID for you. Firefox does not — in MV3 you must state it: "browser_specific_settings" : { "gecko" : { "id" : "kh4-companion@dhseadev.online" } } The email-ish form or a {8-4-4-4-12} GUID both work. Pick carefully: this ID is your update identity forever. Changing it later means a new listing, not an update. 2. There are no extension service workers in Firefox This is the real difference, and it is smaller than it sounds. Firefox runs an event page where Chrome runs a service worker. background.service_worker is simply ignored, with a BACKGROUND_SERVICE_WORKER_IGNORED warning. The cross-browser answer is the dual key: "background" : { "scripts" : [ "core/lib.js" , "background.js" ], "service_worker" : "background.js" } Chrome reads service_worker . Firefox reads scripts . One file, both browsers. Two traps live in here, and both pass a manifest review and fail at run

Originally published on hexisteme notes . I set a threshold from measurement instead of guessing. The measurement was clean: zero overlap between the two clusters, a 33x gap between them. I wrote the numbers into a comment with their sample sizes, feeling good about not having guessed. It was wrong, because the sample I had labelled "known good" was one of the bad ones. I've written before about checks that cannot fire — guards whose thresholds were miscalibrated for the scale of their input, so nothing you fed them ever tripped the line. This is a different animal. My threshold was calibrated from data . That's exactly what made it convincing, and it's why the calibration itself is where the bug lived. The check A video pipeline burns captions onto a rendered preview. A gate then diffs the burned output against the preview and treats every changed pixel as "text we drew," so it can ask whether our captions intrude into the platform's UI safe area. That reading only holds if the two files are a pair — if this output was burned from this preview. Nothing verified that. The only guard compared the number of sampled frames . Sampling is time-uniform, so two generations whose durations differ by 0.1s both yield exactly 60 samples. The guard was structurally incapable of noticing the thing it was nominally there to notice. Setting the threshold I wanted a statistical backstop: if the whole-frame difference between the two files is too large, they probably aren't a pair, so refuse to render a content verdict at all. Exactly one episode in the repo had both files sitting on disk. I used it as my positive control. sample median whole-frame abs diff "correctly paired" episode 19.51 known-mismatched pair 98.65 Threshold: 55.0. Zero overlap, a 33x gap. Two clusters, cleanly separated. Done. The control was a negative That episode's preview file had an mtime nine hours later than its output — and later than the gate run that had already approved it. The preview on disk had been

Most performance optimization focuses on making each operation faster. HKD Kernel approaches a different question: What if most of those operations did not need to execute at all? I’ve been working on HKD Kernel, a native C library for exact sparse and incremental computation. The target workload looks like this: A large computation has already been evaluated. Only a small subset of the inputs changes. The dependency structure tells us which results can actually change. HKD recomputes those affected regions instead of repeating the entire calculation. The important word is exact. The optimized result must equal the result of full recomputation. What the benchmark measures The repository contains reproducible benchmarks comparing full recomputation with the HKD incremental path. Across the benchmark suite currently documented in the repository, the measured mean speedup is roughly 18,000x. That requires an important qualification: This does not mean HKD makes arbitrary programs 18,000x faster. It means that on workloads with sparse changes and reusable state, avoiding redundant computation can produce extremely large reductions in work. That distinction is important enough that I built the repository around reproducibility rather than a black-box benchmark claim. What HKD Kernel is not HKD Kernel: does not replace the macOS XNU kernel does not modify CPU microcode does not disable SIP does not change processor ALU hardware It is a user-space native computation library. Where I think this model is useful The workloads I’m most interested in include: dependency graphs incremental build systems large simulations with sparse updates optimization systems financial/risk recomputation logistics and scheduling cached numerical pipelines The real question is not “how fast is HKD?” It is: How much of your current computation is being repeated even though the inputs affecting it never changed? I’d especially like developers to try to break the benchmark assumptions or suggest w

I just wrote about the billion-dollar rounds flooding into humanoid robotics. Here is the story from the other end of the scale, and I find it more encouraging. Hugging Face's open-source robot, a 25-centimeter bipedal machine with fifteen actuators and a sensor kit that includes a camera, speaker, LiDAR, NFC, Bluetooth, and WiFi, just passed a million dollars in sales. Fully open hardware, openly documented, quietly making real money. One of these robotics stories is funded like an industrial giant. The other is a small, open, shippable thing that people are actually buying. They are both true, and the small one is the one most builders can learn from. Open hardware turned out to be a business The reflexive assumption about open-source hardware is that you cannot make money on it, because anyone can copy the design. Hugging Face's robot is a live counterexample. The plans are open, the software stack is open through their LeRobot ecosystem, and it crossed a million in sales anyway. That is worth sitting with, because it means openness and revenue are not the opposites people assume. The reason it works is the same reason open-source software companies work. Most buyers do not want to source fifteen actuators, fabricate a chassis, and debug a sensor stack to save money on a robot that already exists and is affordable. They want the finished thing, they want it to work out of the box, and they are happy to pay the people who designed it. Openness is not the giveaway that kills the business. It is the trust and the ecosystem that make the business, because you can see exactly what you are buying, modify it, and build on a platform other people are also building on. Why this is the better story for builders The mega-funded humanoid companies are placing a bet only a handful of players can place: billions of dollars, years of runway, factories. That is a real path, and it is not your path or mine. The Hugging Face robot is the other path, and it is copyable. Small, open

As my 20s are set to come to an end later this year, I’ve officially reached the age where sleeping in the wrong position or stretching just a little too far can cause aches and pains. I’ve always been somewhat skeptical of massage guns, mostly because I’ve tried a few off-brand ones and just assumed […]

What Is Precision Tracking Radar? Precision tracking radar is an active radar sensing system designed to repeatedly measure a selected target and maintain an updated estimate of its state over time. For developers, the important distinction is that precision tracking is not simply repeated target detection. Detection answers: Is there evidence of a target in the current radar measurements? Tracking answers: Does this new measurement belong to an existing target, and how should that target state be updated? A practical precision tracking pipeline can be represented as: RF sensing → target measurement → detection → association → state update → continuous track → mission output That makes precision tracking radar a real-time data-processing system as much as an RF sensing system. A Practical Definition Precision tracking radar is a radar capability that combines repeated target measurements across time to maintain a continuous estimate of target position, motion or other relevant state information. The key word is continuous. A detector can operate independently on each radar update. A tracker has memory. It maintains information from previous measurements and decides how new observations relate to that history. From a software architecture perspective, tracking introduces persistent state into the sensing pipeline. Detection and Tracking Should Be Separate Services A useful radar architecture keeps target detection and target tracking logically separate. The detector processes current radar measurements. The tracker consumes target-related measurements over time. Conceptually: Radar measurement ↓ Detection ↓ Measurement object ↓ Association ↓ Track update ↓ Track state This separation helps developers understand where errors originate. If the detector produces unstable measurements, the tracker cannot fully repair them. If detections are stable but tracks switch between targets, the problem may exist in association. If sensor-relative detections are correct but missio

Are XREAL's smart glasses the way of the future for home entertainment?

James Cameron's 1991 sci-fi blockbuster returns to theaters this weekend for its 35th anniversary.

Previously I have a macOS App I use myself, gemini-live-translate-macos . It uses ScreenCaptureKit to directly capture audio from a specified App, eliminating the need for virtual sound cards like BlackHole. It then sends the audio to the Gemini Live API for real-time translation, outputting Traditional Chinese subtitles while playing Chinese audio. I've written two posts about the development process: the first one was about building it from scratch using AGY CLI, and the second one was about using Claude Code to take it from "functional" to "user-friendly." The starting point for this new addition was simple: I saw a document for "Real-time Transcription" added to the Live API. Since I was already connected to the Live API, I thought adding a pure transcription mode would just be a matter of changing a few parameters. However, after checking the documentation, I realized that Google released two models with very similar names but very different capabilities at once. The specific feature I actually wanted (speaker diarization) wasn't available at all on the model I originally thought it was. Two Models with Names Differing by Only Two Words Let's lay out the differences first; this is the part I spent the most time figuring out: gemini-3.5-transcribe-live gemini-3.5-transcribe API Used Live API (WebSocket streaming) Interactions API (Standard HTTP request) Usage Scenario Transcribe while speaking Upload the whole file after recording Speaker Diarization Not supported Up to 8 speakers Word-level Timestamps Not supported Supported Audio Length 10 minutes per session 1 hour (30 mins with diarization) Smart Mode SMART available smart is mutually exclusive with diarization Interim Subtitles Has interimInputTranscription Not applicable The official documentation on the Live page's limitations section is very blunt: Speaker diarization is not supported in live streaming sessions. For speaker diarization, use the non-streaming Audio transcription endpoint. So, "seeing who

A ideia de um sebo que não perde estoque: No primeiro período, nosso grupo desenvolveu um Sebo Virtual. O objetivo era resolver a dificuldade de sebos tradicionais em conciliar estoque físico e virtual, com pagamento via PIX e envio de recibo por e-mail. Minha responsabilidade foi a engenharia de prompt utilizando o Lovable. Quando a IA não entendia o que eu queria: Os primeiros prompts retornaram resultados incompletos. Ao solicitar "explique o código por trás da aplicação", a resposta foi genérica e não detalhou a integração com o banco de dados. Também houve dificuldade em fazer a ferramenta compreender fluxos específicos, como leilão de itens, validação de cupons e cálculo de frete por CEP. O que mudou quando usei diagrama e contexto: O resultado melhorou quando passei a incluir contexto e artefatos. Três prompts funcionaram bem: para wireframe, enviei o diagrama e solicitei o protótipo das telas; para o leilão, pedi quatro telas com checkout e histórico de transações; para o back-end, solicitei as linguagens utilizadas e o fluxo de integração ao banco preservando as informações da documentação. Com isso, identifiquei a stack gerada: React com TypeScript no frontend e Supabase no backend, com consultas como from('pedidos').select('*').eq('usuario_id', id) . Do sebo para qualquer loja online: As regras implementadas, como cupons LIVRO10 e SEBO20, frete proporcional ao peso e checkout via PIX para o endereço base na Rua dos Livros, 707, João Pessoa, são aplicáveis a qualquer e-commerce de pequeno porte. O método permite transformar uma ideia em protótipo navegável em poucas horas. O que levo disso para a carreira? O projeto mostrou que, além do código, a capacidade de formular perguntas claras e organizar a documentação em fluxograma e diagrama de classes é fundamental. Foi meu primeiro case prático e base para portfólio na área de dados e produto. EN Summary: As a first-semester student, our team built a Virtual Bookstore to manage physical and online inventory w

Meta has detailed MTIA 300, its first in-house accelerator optimized for training ranking and recommendation models. By Matt Foster

Startups building B2B products reach for multi-tenancy in PostgreSQL the same way on day one: one shared database, one set of tables, and a tenant_id column marking who owns each row. That is the correct call, and it stays correct for a long time. However, when that column is enforced by application code rather than by the database, a single forgotten predicate stops being a bug and becomes a disclosure event, and a disclosure event is one of the very few engineering failures that lands straight on your balance sheet as stalled enterprise deals, an unplanned legal bill, and a security review you can no longer pass. By understanding what multi-tenancy actually guarantees, which isolation model fits your stage, and how Row-Level Security moves that guarantee out of your codebase, startup CTOs and Fractional CTOs can make the tenant boundary hold without slowing the team down. (If you want to skip the theory, jump straight to the connection pooler trap that switches Row-Level Security off in production, what it costs in query performance, or when it is genuinely time to leave the shared schema.) Because "enforced by application code" means something very specific in practice. It means a promise that everyone will remember to filter on tenant_id , and that promise is the single most expensive line of undocumented policy in your entire codebase, because it holds perfectly for about fourteen months, right up until the afternoon a tired engineer ships a reporting endpoint that joins four tables and forgets the predicate on exactly one of them, and then a customer opens a dashboard and sees somebody else's invoices. That is not a bug. A bug is something you fix on Monday. A cross-tenant data leak is a disclosure event, which means legal gets involved, your enterprise prospects get an email from their own security team, and the deal that was supposed to close your Series A quietly moves to next quarter and then to never. The uncomfortable part is that this is not a story abo

ToolJet was the first internal tool builder to go AI-native, but ToolJet MCP takes that idea...

July wasn’t a particularly pleasant month for me. I was affected by the restructuring of the company...

Google teamed up with the Pokémon Company to introduce a special-edition Fitbit Air that works with the Pokémon Sleep app.