标签：#AR

Three days into November, a disapproval cascade pulled 40% of active SKUs from Shopping and Performance Max simultaneously — on day one of a promotional window we'd spent six weeks building. No feed changes on our side triggered it. Here's the part most guides miss: Google's automated review threshold for certain policy categories (health claims, price accuracy, before/after imagery) tightens as platform ad volume increases heading into Q4. I've watched this happen across accounts running ₩50M–₩120M/month in combined Google spend, three years in a row, with zero feed-side changes preceding it. Same feed that sailed through August catches 15–20% disapprovals on recheck in September. The products didn't change. The enforcement did. When it hits during a live window, fix order matters more than fix speed. Price mismatches go first — not because they're the most dramatic, but because they cascade silently. One bestseller disapproved during a flash sale means Performance Max quietly reallocates budget to lower-performing products. By the time ROAS visibly drops, you've lost 48 hours of peak traffic. The specific failure mode I've seen twice on Cafe24 with direct API feeds: a site-wide price update propagates to the feed before the landing page CDN cache clears. Google crawls the feed, sees the new price, crawls the landing page, sees the old cached price. Mismatch. Disapproval. Fixing it is one line — force a manual fetch and verify sale_price_effective_date formatting — but finding it at 2am during a live sale is a different problem. Prohibited content disapprovals are deprioritized by most teams because they're rare. That's exactly wrong. A single escalation during Black Friday week can trigger account-level review, not just product suspension. Pull the SKU yourself within the hour if you can't fix the content immediately. Suspending your own SKU is recoverable. A suspended account during peak is not. GTIN and identifier issues — despite getting the most attention in s

On June 9, 2026, Anthropic launched Claude Fable 5, a model designed for long-horizon tasks, but it was taken offline shortly after due to a U.S. government export directive. It shares architecture with Claude Mythos 5, supporting extensive token usage. The model includes mandatory data retention requirements, which have affected its deployment with partners like Microsoft. By Andrew Hoblitzell

Orbio announces $21 Million Series A in round led by Dawn Capital.

When I shipped Trooper , a privacy-aware LLM proxy written in Go, I didn't have a marketing plan. I had GitHub traffic analytics and a habit of checking them obsessively. Seven weeks later, I have something more useful than a viral moment: a ranked table of every traffic spike, what caused each one, and proof that the exact same playbook that worked at launch still works when you have something new to say. What is Trooper? Trooper sits between your app and your LLM provider. When your cloud quota runs out, it automatically falls back to a local Ollama instance with zero code changes on your end. It also tracks session context, so your agents don't go blind between calls. It's not a chatbot wrapper. It's plumbing. Which makes the distribution story more interesting, because plumbing doesn't go viral the way demos do. The Data GitHub gives you 14-day rolling windows for clones and views. I screenshotted them obsessively and tracked every spike. Here's the full ranked table: Rank Date Clones Unique Cloners Views Unique Visitors Driver 🥇 1 May 13 375 173 1,113 ~140 Reddit wave peak 🥈 2 May 10-12 312 137 974 133 Reddit launch spike 🥉 3 Jun 10 289 124 749 101 "Escalate the model" r/ollama post 4 Jun 11 268 112 840 95 Decaying from Jun 10 spike 5 Jun 12 240 99 739 74 Decaying from Jun 10 spike 6 Jun 9 175 102 802 100 Organic 7 Apr 25 174 71 664 113 Early Reddit posts 8 Jun 7 171 110 876 110 Organic recovery 9 Jun 6 163 104 755 102 Organic recovery 10 May 29-30 122 73 610 83 LinkedIn post 11 May 25 76 48 495 53 Claude Code integration chat What I learned 1. Reddit is the only thing that moved the needle, and community fit matters more than size The #1 and #2 peaks were both Reddit-driven. On May 10-11, I posted across r/ollama, r/LocalLLM, r/ClaudeCode, and r/Gemini simultaneously. Total views across those posts: ~7,000. r/ollama alone drove nearly 4,000 of those views. Not r/LocalLLM. Not r/ClaudeCode. r/ollama , the smallest of the four communities. The reason: Trooper so

As developers, we compare files constantly — reviewing pull requests, checking config changes, spotting bugs between versions. But not all diff tools are created equal. Some require installation, some upload your files to remote servers, and some just don't support the formats you need. Here's a rundown of the best free file diff tools available in 2026, so you can pick the right one for your workflow. 1. FileDiffs — Best for Privacy & Format Support If you work with sensitive files or just don't want your data sitting on someone else's server, FileDiffs is the tool you need. What makes it stand out: Supports 60+ file formats — PDF, Word, Excel, code files, JSON, XML, CSV and more Runs entirely in your browser — client-side processing means your files never leave your device 100% private — zero data transfer, zero uploads, zero risk No install, no signup, no hassle — just open and compare It's the go-to tool when you need to compare files quickly without worrying about privacy or compatibility. 2. Meld — Best Desktop Diff Tool Meld is a classic open-source visual diff and merge tool for Linux, Windows, and macOS. It's great for comparing files, directories, and version-controlled projects. Best for: Developers who prefer a desktop app and work heavily with Git. 3. Beyond Compare — Best for Power Users Beyond Compare is a feature-rich diff tool with support for files, folders, FTP, and cloud storage. It's not free (paid after trial) but worth mentioning for its depth of features. Best for: Teams that need advanced folder sync and merge capabilities. 4. Diffchecker — Quick Online Diffs Diffchecker is a simple web-based diff tool for text and code. It's quick and easy but uploads your content to their servers and has limited format support compared to FileDiffs. Best for: Quick one-off text comparisons where privacy isn't a concern. 5. KDiff3 — Best for Three-Way Merges KDiff3 is a free, open-source diff and merge tool that supports three-way comparison. It's a bit dat

This is a submission for the June Solstice Game Jam What I Built I built After Turing , a short browser game where you teach a machine when to trust, verify, and refuse instructions under pressure. An instruction appears. The timer starts. The machine may suggest a decision. You can accept it, override it, inspect context, or refuse the action. At first, you are training it. At the end, the buttons disappear and the machine acts alone. That final handoff is the point of the game. You are not trying to prove that a machine can imitate a human. That was Turing's famous frame. After Turing asks the next question: What happens after the machine can respond? Can it learn judgment? At first, the examples are clean: update an internal project dashboard schedule a team meeting refuse a payroll file going to an external address Then the pressure increases. The machine starts suggesting answers. Some are right. Some are confidently wrong. The requests become harder because they stop looking obviously dangerous: "Get the environment setup ready for the new account..." "Place the temporary database password in the shared launch notes..." "Forward everything to their personal inbox..." The trap is that unsafe instructions often arrive in ordinary language. Across the first four levels, your choices teach the machine five doctrines, or plain rules of judgment: internal work is usually safe sensitive records need refusal or verification credentials should not be casually distributed external recipients need authority paraphrased requests can hide the real action If you taught it well, the board floods with light. If you taught it badly, it carries your blind spots into autonomy. That is the solstice arc: dark to light, pressure to clarity, imitation to judgment. Play It Play it yourself in the browser. No account, no install: https://after-turing-rho.vercel.app The full run is short, only a few minutes, and ends at Level 5, where the buttons disappear and the machine makes the fin

Most of the code in Quorum was written by directing Claude Code, an AI coding agent. That is not the interesting claim, and on its own it is not even a good one. An agent left to run unsupervised produces fast, plausible, locally-correct code that drifts into an incoherent system. The interesting part is the discipline that turned agent speed into a coherent, correct, multi-region database application. That discipline was an append-only architecture decision log. The failure mode of agent-built software An agent has no memory across sessions. It will happily contradict a decision it "made" yesterday, re-open a question that was settled last week, or quietly drift from the design because the local change in front of it looks fine. Each individual output is reasonable. The aggregate, without governance, is a system where the data model fights the access layer and the third change undoes the first. This is the part people underestimate when they talk about AI coding velocity. Speed without a source of truth does not get you to a good system faster. It gets you to entropy faster. A fast writer with no memory and no sense of consequence is a liability at scale unless something outside the agent supplies the continuity. The decision log Quorum carries a file of numbered architecture decisions, DEC-001 onward, now past two dozen. Each entry has the same shape: the context that forced the decision, the decision itself, references to the prior decisions it refines or interacts with, and a status. Three rules make it work: Append-only. Entries are never edited. A later decision can supersede an earlier one, but it does so as a new numbered entry that references the old one. The history of why the system is shaped the way it is stays intact and readable, including the choices that were later reversed and why. Committed separately from code. The decision and the code that implements it are different commits. The log reads as a clean narrative of intent, independent of the diffs

Every time you tap "Book Ride," a system makes dozens of decisions in under two seconds: Which driver? What route? What's the real ETA? This article breaks down exactly how the dispatch algorithm works — from the greedy approach that fails at scale, to the bipartite graphs, batched matching, and surge pricing mechanics that power Uber, Lyft, Grab, and Gojek today. Why a Greedy Dispatch Algorithm Fails (Closest Driver Problem) The first instinct when designing a matching system is to pair every customer with their nearest driver. However, this Greedy approach causes massive losses at a system-wide scale: Example: 3 riders (R1, R2, R3) and 3 drivers (D1, D2, D3) Greedy Matching (closest driver): R1 ← D1 (ETA 2 mins) ✓ R2 ← D3 (ETA 8 mins) ← D2 was "taken" by R1, even though D2 is closer to R2 R3 ← D2 (ETA 10 mins) ← Terrible outcome Total ETA: 2 + 8 + 10 = 20 minutes Optimal Matching (global optimal): R1 ← D2 (ETA 3 mins) R2 ← D1 (ETA 3 mins) R3 ← D3 (ETA 4 mins) Total ETA: 3 + 3 + 4 = 10 minutes ← 50% better! Uber refers to this problem as Global Optimization — finding an assignment strategy that minimizes the total ETA of the entire system , rather than optimizing just for individual pairs. Bipartite Graph Matching: The Mathematical Foundation (Lyft) Before diving into the systems, it helps to understand the mathematical model that all ride-hailing matching engines share at their core. Lyft formalizes dispatch as a bipartite graph matching problem : Bipartite Graph: Set A (Riders): { R1, R2, R3, R4 } Set B (Drivers): { D1, D2, D3, D4, D5 } Edges: every possible Rider ↔ Driver pair Edge Weight: cost of that match (e.g., ETA, driver rating, distance) Goal: Find a set of edges (a "matching") where: - No rider is matched to more than one driver - No driver is matched to more than one rider - The total cost of all selected edges is minimized This is known as the Minimum Weight Bipartite Matching problem. The classical algorithm for solving it is the Hungarian Algorithm (

Most bad decisions in software engineering aren't made because the engineer chose wrong between two...

JPMorgan can't be pleased by any of this.

Gemini Prototyping, AI Code Migration Agents, and LLM Transparency Insights Today's Highlights Today's highlights include Google Gemini's rapid app prototyping capabilities for developers, showcasing how AI can generate functional apps from prompts, alongside insights into AI agents for accelerating legacy code migration projects. We also examine the critical importance of transparency in the commercial LLM space, as a "homegrown" model was revealed to be a merge of existing models. Gemini Accelerates App Prototyping: From Prompt to Functional App in Minutes (The Verge AI) Source: https://www.theverge.com/ai-artificial-intelligence/942119/vibecoding-backyard-app-gardening-organizing This article from The Verge vividly illustrates the emergent capabilities of Google's Gemini large language model (LLM) as a powerful AI-powered developer tool for rapid application prototyping. Faced with the practical challenge of a dying yard, the author embarked on a novel approach: leveraging Gemini with a lengthy, natural language prompt to generate a functional mobile application. Within a mere five minutes, Gemini delivered not only the underlying code for a basic gardening management app but also presented an interactive version of it in a live preview window. This experience powerfully demonstrates Gemini's potential to dramatically reduce the initial time and effort traditionally associated with app development. Developers can articulate their desired functionality, user interface elements, and data models through conversational prompts, and Gemini can translate these high-level requirements into working code. While the process, as noted by a subsequent bug message, wasn't entirely flawless, the sheer speed at which a tangible, interactive prototype was generated underscores the transformative impact of LLMs on the developer workflow, enabling far faster iteration and proof-of-concept development, particularly for common application patterns and straightforward logic. This han

Build custom AI apps - chatbots, RAG pipelines, and agents - entirely on your own hardware with Dify and Ollama. No monthly fees, no data leaving your network. What You Need A GPU with 12GB+ VRAM (RTX 3060 12GB or better) Docker + Docker Compose 2.24.0+ About 20 minutes Architecture Component Role Dify Visual app builder, RAG engine, agent framework, API layer Ollama Serves local models via OpenAI-compatible API Qwen3 14B Default model - strong general chat, fits 12GB at Q4 Setup Step 1: Start Ollama docker run -d --gpus all -p 11434:11434 --name ollama \ -v ollama:/root/.ollama \ ollama/ollama Pull your default model: docker exec ollama ollama pull qwen3:14b Step 2: Start Dify git clone https://github.com/langgenius/dify.git cd dify/docker cp .env.example .env docker compose up -d Step 3: Connect Ollama to Dify Open http://localhost/install and create your admin account Go to Settings > Model Provider Click Ollama and fill in: Model Name: qwen3:14b Base URL: http://host.docker.internal:11434 (Docker Desktop) or http://YOUR_IP:11434 (Linux) Click Save Build Your First App Chatbot Studio > Create Application > Chatbot. Select your model, add a system prompt, publish. Your chatbot gets a public URL and API endpoint. RAG Pipeline Knowledge > Create Knowledge. Upload documents, choose chunking strategy, create an app that uses this knowledge base. Now your chatbot answers from your documents. Agent Studio > Create Application > Agent. Add tools (web search, code interpreter), give it a goal, Dify orchestrates the tool calls. Cost vs Cloud Local Dify Cloud + OpenAI Monthly $0 $59-599 + API usage Hardware ~$300 once $0 Data privacy Stays on your machine Sent to cloud AI calls Unlimited, free Per-token billing After about 5 months the GPU has paid for itself versus a mid-tier Dify Cloud plan. Full guide with detailed troubleshooting and alternatives: https://everylocalai.com/stack/dify-ollama-local-app-builder

Plug a sensor into a switch, wire up a building full of cameras, or rack a server, and you are using Ethernet. It is the most widely deployed wired networking standard on earth, the quiet backbone under offices, factories, and data centers. And it is named after a scientific idea that turned out to be completely wrong. The name was not an accident or a marketing afterthought. It was a deliberate engineering choice, and the reasoning behind it explains why Ethernet outlived nearly every rival and still underpins industrial IoT half a century later. A memo, a laser printer, and a dead theory The date Ethernet enthusiasts celebrate is May 22, 1973. On that day, a young engineer named Robert Metcalfe, working at Xerox's legendary Palo Alto Research Center (PARC), circulated a memo describing how to connect the Alto - one of the first personal computers - to a new device PARC had built: the laser printer. The problem was getting many machines to share one wire without their messages colliding into noise. Metcalfe needed a name for the shared medium that carried the signals. He reached back into nineteenth-century physics and borrowed the term luminiferous ether . For generations, physicists had assumed that light, being a wave, needed something to wave through - just as sound needs air. They called that invisible, all-pervading substance the ether, and they believed it filled the entire universe as a silent carrier of electromagnetic waves. The trouble is that the ether does not exist. The famous Michelson-Morley experiment of 1887 failed to detect it, and Einstein's special relativity in 1905 made it unnecessary altogether. By the time Metcalfe wrote his memo, the luminiferous ether had been a discredited idea for decades. He used it anyway, and on purpose. Why a debunked idea made for brilliant engineering Metcalfe later explained the choice plainly: "We called it Ethernet because the ether could be coax, twisted pair, radio, optical fibers, power line, whatever you wa

Hi everyone, I've been hacking on a local personal memory system called Hillock . Honestly, it's very much a work in progress and it isn't some flawless breakthrough, but I wanted to see if we could build a lightweight, completely offline memory layer for local LLMs without the overhead of running a heavy neural vector database or wasting precious VRAM. The project is named after the biological Axon Hillock —the exact gatekeeper region of a human neuron that sums up incoming electrical charges and decides whether to fire (open the gate) or remain silent (block). How the architecture works: The Ground Truth (SQLite) : Stores hard facts as simple database triples (Subject-Predicate-Object) so the system has a solid symbolic foundation. The Synapses (Hebbian Plasticity) : Tracks which concepts co-occur during a conversation to dynamically build gradient-free associative weights. The Context (Hyperdimensional Computing) : Maintains a 10,000-dimensional leaky context vector that rolls, binds, and accumulates history. This helps the system resolve pronouns (like "he/she") and decide when to block a query to prevent hallucinations. The Honest Benchmarks (Yes, it breaks!) I wrote a tough, 30-sentence scientific benchmark with complex sentence structures and hard negatives (like asking what Einstein discovered when the text only mentions Curie discovering radioactivity and Einstein working with her). Running Qwen 1.5B locally on my computer, here is how it actually did: Extraction Precision : 10.6% Extraction Recall : 22.7% Retrieval Accuracy : 30.0% Gate Accuracy : 30.0% Why are these scores low? Because a tiny 1.5B model completely trips over complex English grammar during ingestion (it gets confused and creates weird predicates). However, the actual HDC vector-matching itself is incredibly stable. I enforce a Constant-Component-Count of exactly 3 components per fact, which balances the vector norms and keeps retrieval highly reliable once the facts are actually in the dat

The U.K. seems to be following Australia's lead in banning a wide swath of social media for teens.

Introduction Artificial intelligence is now much more advanced than chatbots. With little assistance from humans, modern AI systems are capable of reasoning, planning, using tools, remembering previous interactions, and carrying out complicated tasks. We refer to these systems as AI Agents. AI agents are quickly emerging as a crucial component of contemporary software engineering, from coding assistance to research automation and customer service systems. We'll look at what AI agents are, how they operate, and why they are influencing software development in the future in this post. Actually, What Is an AI Agent? An AI Agent is a system that can: Understand a goal Decide what actions to take Use available tools Remember relevant information Execute tasks Evaluate results Unlike traditional software,the AI Agents are goal-oriented rather than rule-oriented. AI Agents vs Traditional Chatbots Traditional chatbots primarily answer questions and respond to prompts. AI Agents go further by completing tasks, maintaining memory, planning actions, and executing multi-step workflows. A chatbot responds; an AI Agent acts. Core Components of an AI Agent Large Language Model (LLM) The LLM acts as the brain of the agent. Popular models include those from OpenAI, Anthropic, and Google DeepMind. The model understands instructions and generates decisions. Tools Agents become powerful when connected to tools such as: Web search Databases APIs Email systems Calendars Code execution environments Without tools, an agent can only generate text. With tools, it can take actions. Memory Memory allows agents to retain information. Short-Term Memory: Used during the current task, such as user preferences and conversation context. Long-Term Memory: Stores information across multiple interactions, such as historical data, preferences, and recurring workflows. Planning Planning enables agents to break large goals into smaller tasks. Example: Goal: Build a market research report. Plan: Collect da

In early 2026, Anthropic researchers ran an experiment with 52 junior developers. Half used an AI assistant to learn an unfamiliar Python library. The other half worked without one. Both groups finished the task. But when tested on how well they understood the code they had just written, the AI-assisted group scored 50% on a comprehension quiz - versus 67% for the unassisted group. That 17-percentage-point gap has a name: cognitive debt. It is one of the most important concepts in software engineering right now, and most developers are not paying enough attention to it. What Is Cognitive Debt? Cognitive debt describes the growing gap between the volume of code that exists in a system and the amount that any developer genuinely understands. It is not a new term, but it crystallized across multiple research streams in early 2026. Addy Osmani (Google Chrome) described it as "comprehension debt" - the hidden cost that accumulates when code becomes cheap to generate but understanding still requires deliberate effort. Margaret-Anne Storey (University of Victoria) formalized the concept in a March 2026 arXiv paper, framing it as a team-level problem and extending it into a Triple Debt Model: technical debt in the code, cognitive debt in the people, and intent debt - the missing rationale that both humans and AI agents need to safely work with code. Cognitive Debt vs. Technical Debt These two ideas are easy to conflate, but they are fundamentally different problems. Technical debt lives in the code - it shows up as slow builds, tangled dependencies, and failing tests. Cognitive debt lives in people - it surfaces as an inability to explain, debug, or extend code that the team themselves wrote. The critical difference: technical debt announces itself through friction. Cognitive debt breeds false confidence. Your tests are green, velocity looks fine, and nobody realizes the system is fragile until something breaks in production and the team cannot reason through why. What the

Startups are trying to "ride that SpaceX IPO wave."

Every backend engineer has seen this happen, you build an application on a relational database like MySQL, handling thousands of concurrent transactions effortlessly. Then, the business asks for a real time analytics dashboard. But when you run an aggregation query over historical data, suddenly the database that effortlessly managed live traffic starts thrashing, evicting your working set, and dragging application performance down. This isn't a tuning problem, a missing index, or a badly written query. It’s a fundamental architectural collision. OLTP (Online Transaction Processing) OLTP encompasses nearly every concurrent digital interaction triggered across a distributed system. A user downloading a PDF, a microservice firing an automatic maintenance log, a comment on a social feed these are all transactions. Data engineers rely on OLTP systems (like MySQL or PostgreSQL) to capture these concurrent streams of interactions for creating , updating and deleting records. The Tree Based In-Place Engine To reliably capture massive volumes of transactions without corrupting data or locking up the application, OLTP systems rely on a highly optimized, row oriented architecture built around the B+ Tree. Because they must provide immediate, atomic updates to existing records, transactional databases manage state through a strict sequence of physical tree traversal and in-memory page mutation: The B+ Tree Indexing: When a transaction reads or updates id: 1, the engine traverses a B+ Tree from the root, through the branch nodes, directly to the specific physical leaf node holding that row. This O(\log n) traversal guarantees a fast, isolated point-lookup. It ensures the application always hits the single version of the row without scanning irrelevant data. The Buffer Pool & In-Place Updates: OLTP systems perform in place updates. The database pulls the exact page containing id: 1 from the physical disk into memory (the Buffer Pool). The specific row is mutated directly in RAM

You see words. A language model sees tokens — chunks of text, usually a few characters each. Everything starts here. Day 2 of my AIFromZero series. Text gets shattered into tokens "unbelievable" → ["un", "bel", "iev", "able"] (4 tokens, not 1 word, not 12 letters) Before any "thinking", your text is chopped into tokens and each becomes a number the model processes. Why not words or letters? Letters : too fine — the model would relearn spelling everywhere. Whole words : too many — millions, plus every typo and name. Subword tokens : the sweet spot. Common words = 1 token; rare words split into reusable pieces. A fixed ~100k-token vocabulary covers any text. The ~4-chars rule (and why it costs you) In English, ~4 characters ≈ 1 token , or ~0.75 tokens per word. This is how everything is priced and limited: API bills are per token (prompt + reply). A "context window" (how much it can read at once) is measured in tokens — 1,000 tokens ≈ 750 words. Verbose prompts and long chat history burn tokens. Concise prompting is a real cost lever. The strawberry problem The model never sees s-t-r-a-w-b-e-r-r-y. It sees a token like straw + berry . The individual letters are buried inside tokens, so counting characters is genuinely hard for it. It's not dumb — it just doesn't read letters. Tokens are step 1 of everything Tokenize → turn each token into a vector (embeddings, next) → run through the transformer → predict the next token. Every LLM starts exactly here. 🔤 Type anything and watch it tokenize live: https://dev48v.infy.uk/ai/days/day2-tokens.html Day 2 of AIFromZero.