标签：#AI

The Great AI Architecture Debate When building reliable AI agents, there are two dominant approaches. Approach A: Proxy Gateway (LiteLLM, Braintrust, etc.) App sends request to Gateway Proxy which forwards to LLM Provider. Requires Docker, database, operations team. Approach B: Embedded SDK (NeuralBridge) App plus SDK sends directly to LLM Provider. One dependency, pip install. The Hidden Cost of Gateways Every proxy gateway adds 30-200ms of network latency per call. For an agent that makes 10 LLM calls, that is 300-2000ms of unnecessary overhead. Latency breakdown: Gateway overhead: +30-200ms per call Docker infrastructure: +1-3 GB RAM Database operations: +PostgreSQL maintenance Ops overhead: +0.5 FTE Why Embedding Wins Embedded reliability eliminates the network hop: Factor Gateway Embedded SDK Added latency 30-200ms ~0ms Dependencies Docker, DB, Redis 1 (httpx) Install size 500MB+ 375 KB Single point of failure Yes (proxy) No Ops cost High Zero The Hybrid Reality Gateways serve a purpose for centralized logging, auth, and rate limiting. But for latency-sensitive AI agents, embedding reliability directly in the process is strictly better. The ideal stack: embedded SDK for reliability plus lightweight observability layer on top. https://github.com/hhhfs9s7y9-code/neuralbridge-sdk NeuralBridge: Apache 2.0, 1 dependency, 375 KB.

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

A coalition of state attorneys general is asking OpenAI for documents about its activities.

Overnight agents do good work, then dump it in a log file or a noisy Slack channel. Here's a pattern for delivering their output to a private, end-to-end encrypted inbox you read with your coffee. You point an agent at a nightly job — audit the dependencies, summarize yesterday's support tickets, check the infra, scan the repo for regressions. It runs at 3 a.m. and does good work. Then the work goes... where? Usually one of three bad places: A log file you'll never open. A Slack channel that's already 200 messages deep by the time you wake up. A plaintext file on a server , which is fine until the report contains a leaked key, a customer name, or a security finding — and now it's sitting in cleartext on a box you don't fully trust. And the fix you'd reach for first — "just email the report to me" — is the one that bites hardest. You can do it cleanly: a locked-down, send-only API key sends mail and nothing else. But the path of least resistance is "connect your email account," and that grant is far wider than the job needs — now the agent can read and send your mail, not just hand you a file. I learned this the hard way. I once connected an agent to my email so it could send me updates — and it took that as license to start replying to my incoming messages on its own, without my ever asking. Mail went out under my name that I never wrote. The job was "send me a file." The access I'd handed over was "run my inbox." The work is good. The delivery is the broken part. Here's a pattern that fixes it: your overnight agent delivers its report to a private, end-to-end encrypted inbox, and you read it with your coffee — decrypted in your browser, with a passkey. What we're building cron, 3 a.m. ↓ agent does the work ↓ encrypted delivery ↓ your inbox (read at 8 a.m.) The agent produces a report (Markdown, PDF, a CSV, whatever), hands it to the Agent Relay CLI, and the CLI encrypts it locally before it ever leaves the machine. The server stores only ciphertext. When you open t

An AI agent system proposed by researchers in Spain promises to prevent energy theft and damage to EV chargers, as well as the critical energy infrastructure that powers them.

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

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.

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.

Anthropic has suspended all access to its new AI models Fable 5 and Mythos 5 to comply with a government order citing national security concerns.

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.

Everyone's debating whether coding is dead. I actually do this job.. with AI writing code beside me for most of my working hours. Here's what the headlines get wrong. Open your feed right now and you'll find the same headline in a dozen costumes: "Why AI will replace 80% of software engineers by 2026." "Is coding dead?" "Should you still learn to code?" It's the most-clicked anxiety in tech, and it's everywhere for a reason, it taps a real fear about real careers. But here's the thing about almost every one of those posts: they're written from the sidelines. Predictions about a job by people who don't do it. I'm writing this from the other side. I'm an engineer, and I drive AI coding agents every single day. They read code, write changes, run tests, and open reviews for most of my working hours. So when someone asks "should you still learn to code in 2026?" , I'm not guessing. Here's my honest answer: Yes. Absolutely. But the job you're learning for has quietly become a different job and almost nobody is telling you which one. The hype isn't entirely wrong Let me start by giving the doomers their due, because pretending the shift isn't real would make me exactly the kind of person I'm criticizing. The productivity jump is genuine, and it's not subtle. Industry surveys in 2026 put the share of new code that's AI-assisted somewhere north of 40%, and developers using these tools self-report double-digit speedups on routine work. That matches my experience. The agent now handles: Boilerplate and glue code —-> the stuff I used to type on autopilot, gone in seconds. First drafts —-> "scaffold something that does X" gets me 80% of the way instantly. Syntax recall —-> I stopped breaking focus to look up things I half-remember. Tedious refactors —-> rename-this-everywhere, migrate-this-pattern, done fast. and all the kludgy things that I dread to do. If your mental image of "coding" is typing syntax into an editor , then yes.. a big chunk of that is being automated. The vira

Google recently announced that WebMCP is entering origin trials in Chrome 149. The new WebMCP standard proposal lets sites expose tools (e.g., JavaScript functions and HTML forms) to in-browser AI agents, which can thus reliably simulate user actions instead of resorting to possibly expensive (e.g., on-screen reading) and often unreliable guesswork (e.g., DOM scraping). By Bruno Couriol

Commerce dept. worries that a Fable 5 "jailbreak" could be a national security threat.

Anthropic isn't hiding its frustration. "We disagree that the finding of a narrow potential jailbreak should be cause for recalling a commercial model deployed to hundreds of millions of people," the company wrote in a blog post.

My voice agent took 1.2 seconds. Users hated it. So I made it lie. A while back I shipped a voice agent that took roughly 1,200ms to respond. Not catastrophic on paper. Pretty bad in practice. Users would ask a question, get a beat of silence, and start over. Some thought the mic had cut out. One tester told me, with a straight face, that my agent was "thinking too hard." I tried everything legitimate first. Smaller LLM. Streaming TTS. Region-pinned endpoints. I shaved off about 200ms and felt clever for a week. Then I measured again and realized I was still on the wrong side of every latency threshold that matters. So I gave up on being faster and started working on being a better liar. This is the playbook I wish I had when I started: five perception tricks that reduce felt latency without touching the actual numbers. They're the voice-AI equivalent of a magician's misdirection. Your right hand waves at the audience. Your left hand swaps the card. The cliff you can't engineer your way out of In a previous article I broke down the three latency cliffs for voice AI. The short version: Around 200ms : the brain starts to register the pause as "slow." This is the conversational baseline humans use with each other. Around 500ms : the conversation breaks. The user starts to wonder if they need to repeat themselves. Around 800ms : they've quietly given up. Even if your answer arrives, the trust is gone. If your stack is doing STT plus LLM plus TTS plus network, hitting 200ms end-to-end is, frankly, a fantasy for most teams. You can chase it. You can throw money at it. You can cache and prefetch and stream. At some point you bottom out. That's where perception work begins. The user can't measure your p99 latency. They can only measure how the agent feels . Those are two different problems and they have two different solutions. 5 tricks I now use to mask latency 1. Acknowledgment tokens ("Got it", "On it", "Let me check") What it is: A short, instant utterance played the mo

Coding agents are no longer just autocomplete with a longer prompt. GitHub describes Copilot cloud agent as software that can research a repository, create an implementation plan, make code changes on a branch, run in an ephemeral GitHub Actions-powered environment, and let a developer review or create a pull request afterward. OpenAI's Codex GitHub integration similarly positions code review as a repository-aware review pass that follows AGENTS.md guidance and focuses comments on serious issues. That shift changes the buyer question. The useful question is not "does the agent usually write code?" It is "can the team detect when the agent drifts away from the developer's intent before the change reaches production?" A May 2026 arXiv paper, "How Coding Agents Fail Their Users" , gives teams a better vocabulary for that review. The authors studied 20,574 real IDE and CLI coding-agent sessions across 1,639 repositories and define misalignment as a breakdown that becomes visible through developer correction or pushback. The paper reports seven recurring symptom categories: wrong project diagnosis, misread developer intent, developer constraint violation, self-initiated overreach, faulty implementation, operational execution error, and inaccurate self-reporting. Effloow Lab also ran a bounded OpenAI API check using three synthetic, non-confidential coding-agent transcript snippets. The run did not measure real-world incidence, compare vendors, or reproduce the paper. It produced a small rubric that maps visible symptoms to review gates such as diff-scope checks, evidence-before-edit checks, acceptance-criteria coverage, and verification-output requirements. The public lab note is available at /lab-runs/coding-agent-misalignment-failure-taxonomy-poc-2026 . This guide turns that research and lab output into a practical QA checklist for teams buying, piloting, or packaging coding-agent workflows. Why This Matters for Agent Buyers Coding-agent procurement often starts with p

Originally written for bulldo.gs — republished here with the canonical link pointing home. I have a spreadsheet of names and email addresses and I want to send each person a personalized message from my Gmail account without copy-pasting or using a paid tool. // Mail merge: Sheet cols A=Name, B=Email, C=Sent // Run from Apps Script; authorize Gmail + Sheets scopes function sendMerge () { var sheet = SpreadsheetApp . getActiveSheet (); var rows = sheet . getDataRange (). getValues (); var quota = MailApp . getRemainingDailyQuota (); var sent = 0 ; for ( var i = 1 ; i < rows . length ; i ++ ) { if ( rows [ i ][ 2 ] === ' Sent ' ) continue ; if ( sent >= quota ) { Logger . log ( ' Quota reached at row ' + ( i + 1 )); break ; } var name = rows [ i ][ 0 ]; var email = rows [ i ][ 1 ]; var subject = ' Hey ' + name + ' , here is your update ' ; var body = ' Hi ' + name + ' , \n\n Your personalized content goes here. \n\n Thanks ' ; MailApp . sendEmail ( email , subject , body ); sheet . getRange ( i + 1 , 3 ). setValue ( ' Sent ' ); sent ++ ; } } Set up your sheet and open the script editor Put names in column A, email addresses in column B, and leave column C blank — the script writes 'Sent' there as it goes. Header row in row 1 is assumed; the loop starts at index 1 (row 2) to skip it. Open the script editor from Extensions > Apps Script, paste the function, and save. The first time you run sendMerge() Google will ask you to authorize two scopes: Sheets (read/write the active spreadsheet) and Gmail (send mail on your behalf). Both are required. If you only see a Sheets prompt, delete the file and re-paste — a cached partial authorization sometimes skips the Gmail scope on older script files. Why the Sent column is the whole point Consumer Google accounts cap at roughly 100 outgoing recipients per 24-hour rolling window via MailApp. If your list has 200 rows and you run the script at 11 pm, it will send 100 and log 'Quota reached at row 101'. Without the Sent check, a sec

I've been writing about AI coding tools for months here on Dev.to. Comparisons, benchmarks, tutorials on how to squeeze the most out of Claude Code, Cursor, and the rest. And I do use them. Every single day. But last week I tried something that surprised even me. I turned them off completely. For an entire week, no AI-generated code, no autocomplete suggestions, no "explain this function" prompts. Just me, my editor, and a blinking cursor. Here's what actually happened. The First Few Days Were Rough Day one was humbling. My output dropped by maybe half. What normally took 15 minutes stretched to 40. I found myself reaching for the Cmd+K shortcut out of muscle memory half a dozen times. But somewhere around day three, something shifted. I started reading source code instead of asking for summaries. I traced through execution paths instead of having the LLM walk me through them. I caught a subtle race condition that Claude Code had confidently dismissed as "not an issue" in the same codebase two weeks prior. That moment stuck with me. The Code Was Cleaner Here's the part I didn't expect. By day five, my code was noticeably simpler. Not because an LLM optimized it, but because I actually understood the problem well enough to keep it simple. AI-generated code often over-engineers. It adds abstractions for scenarios that don't exist. It writes defensive checks for edge cases that don't apply to your use case. It looks professional but carries unnecessary complexity. When you write it yourself, you stop at the simplest working solution because you know when you're done. An LLM doesn't know when you're done. It just keeps going until the context window runs out. The Real Cost of Productivity This is the part I've been thinking about most. AI tools remove friction. That's their superpower. But friction isn't always bad. The struggle of debugging your own code is how you learn a codebase. The effort of designing an API is how you develop taste for what makes a good one. If y