In my previous article, I argued that AI changes the role of constraints in software...

https://www.youtube.com/watch?v=sVeEc3H6bA4 权重即数据：神经网络权重空间学习如何成为 AI 的下一类训练集 以下位 TWIML AI Podcast 第 772 期《Why Models Are AI's Next Training Dataset》访谈转录整理，嘉宾为圣加仑大学 AI 与机器学习教授 Damian Borth，主持人 Sam Charrington。 介绍详细内容之前，先说说WSL是否等同于模型蒸馏？ 答案是不是一回事，但容易混着叫。先把两件事拆开，再对照 Borth 的"权重空间学习（WSL）"你就清楚了。 1. Anthropic 骂阿里那件事是什么 Anthropic 2026 年 6 月致信美国参议院，说阿里 Qwen 团队在 4/22–6/5 期间用近 2.5 万个假账号调 Claude 约 2880 万次 ，把 Claude 的回答当训练数据去训自己的模型，他们叫它" 蒸馏攻击（distillation attack） "。 这本质上是 黑盒/API 层的数据蒸馏 ： 教师=Claude（只看得到输出文本） 学生=Qwen 系模型 方法=拿 Claude 的生成文本（硬标签，最多再加点软标签）当语料去训学生 目的=迁移能力、省训练钱 注意：这跟"白盒蒸馏"还不一样，阿里（按指控）根本没拿到 Claude 的权重，拿到的是 对话文本 。行业里把"用强模型输出当训练数据"泛称为蒸馏，但严格学术定义里这只是黑盒 KD 或数据蒸馏。 2. Borth 的"权重当数据"是不是蒸馏 形式上沾边，本质上不同。 维度 经典/黑盒蒸馏（Anthropic 指控那种） Borth 权重空间学习（WSL） 学习对象 教师模型的 输出 （文本/软标签/中间激活） 一堆已训练模型的 权重本身 （参数张量） 数据形态 (x, 教师输出) 配对样本 把模型权重序列化、令牌化后的"权重语料" 目标 学生模仿教师行为，压缩模型 学"模型种群"的流形：预测准确率 / 生成新权重 / 跨架构采样 要不要原始数据 黑盒蒸馏可以完全不用原数据，只用教师输出 完全不用任何输入输出数据 ，连教师行为都不看 典型操作 用 Claude 回答训 Qwen 下载 HF 上 2000 个 CV 模型 → 自编码器压成隐空间 → 采样出遥感模型权重 Borth 自己在论文里也承认：WSL 可以看作" 直接在权重上做的、基于训练的知识复用 "，但它不需要像 KD 那样去跑原数据集拿激活、也不需要教师在线推理，它是把"训练好的模型集合"当成 第三种数据模态 （继文本、图像之后）。 简单说： 蒸馏是" 看菜谱做出来的菜（输出）来学做饭 " WSL 是" 把几百道做好的菜称重、切片、分析配料分布，然后直接捏出一道新菜的重量配方 "——连火都没开，更没尝过菜味。 3. 为什么大家会搞混 因为两者都叫"复用已有模型的知识"，而且 WSL 生成出的权重确实能当初始化、能跨域迁移（比如用 ImageNet 模型权重训出遥感模型，350 GPU 小时干掉 12000 GPU 小时的从头训）， 效果上像"蒸馏了前辈经验" 。但机制上： KD 的知识载体是 前向行为 （logits / 文本） WSL 的知识载体是 参数几何结构 （权重空间里的流形、对称性、轨迹） 所以 Borth 在访谈里特意说"权重不仅是学习的输出，也可以是学习的输入"——这句话的潜台词就是： 别把它归类成 KD，它是一个新模态的学习问题 。 4. 一句话收口 Anthropic 抱怨阿里，是"你偷用我家模型吐的字句当教材"；Borth 的路子是"我把全网开源模型（含你家的，只要开源许可允许）的 权重文件 当语料，训一个会造权重的元模型"——前者踩的是 API 条款和商业秘密红线，后者用的是 已发布权重 （Hugging Face 上大多有许可证），技术族谱上离"蒸馏"比离"神经架构搜索 + 超网络"更远。 第（一）部分 节目开场与研究总览：当训练数据枯竭，权重成为新燃料 （0% - 8%） 节目引入与核心命题 ：主持人点明当下 AI 领域最严峻的问题之一——高质量训练数据越来越难找，部分研究者押注合成数据，另一部分押注推理时计算（test-time reasoning）。而本期嘉宾 Damian Borth 提出了一条截然不同的路径：每一个训练好的模型都凝结了数千乃至数百万 GPU 小时"什么管用"的探索经验，这些权重不应只被视为训练过程的终点，而应成为下一次训练的 起点和数据本身 。 嘉宾背景与研究方向 ：Damian Borth 是瑞士圣加仑大学 AI 与机器学习教授。他的核心研究线索是"权重空间学习"（weight space learning / w

This is a cross-post from The Agentic Engineer newsletter — Issue #23. The Big One: Claude Opus 5 Lands on Amazon Bedrock The first 5th-generation Opus is here. Claude Opus 5 landed on Amazon Bedrock on July 24. Anthropic's claim: it matches Fable 5 intelligence across agentic coding, knowledge work, visual understanding, and long-horizon tasks. At Opus pricing. That last part matters. Fable 5 was positioned as enterprise-tier compute. Most teams weren't running it at scale because the economics didn't work. Opus 5 changes that math. Same capability class, Opus price point. If the benchmark holds in production, this is the model shift that makes frontier-quality agentic pipelines practical outside big-company infra budgets. Two deployment details worth calling out. Zero Data Retention is on by default. It also runs on Bedrock's next-generation inference engine — lower latency than comparable Anthropic-hosted deployments. Quick Hits This Week Kimi K3 Open Weights : Moonshot AI dropped 2.8T MoE, 1M context, native tool calling. First frontier model built agent-native from the ground up. OpenAI Presence : Full-stack enterprise agent platform with job-scoped access, policy layers, and a Codex-powered improvement loop. Runs OpenAI's own phone support at 75% resolution. OmniRoute : 31,542 stars (+10,912 this week). 290+ providers, quota-aware fallback, MCP/A2A support. One endpoint for all your coding agents. Claude Code 2.1.218 : /code-review and /deep-research now run as background subagents. Main conversation stays clean. AWS Security Hub MCP Server : Exposure findings, attack paths, and remediation recommendations directly in Claude Desktop. Tool of the Week: Amazon GuardDuty Investigation Agent Free during preview. Auto-correlates findings across CloudTrail, VPC Flow Logs, DNS logs. Returns risk level, MITRE ATT&CK mappings, and remediation recommendations in minutes. Available via MCP through the AWS Agent Toolkit. Available in 10 commercial AWS regions. Up to 10 in

I recently passed the Microsoft AB-100 exam as part of the Microsoft Frontier Transformation Engineer journey. 🎉 After previously taking AI-103 , I found AB-100 to be a very different type of exam. While AI-103 is closer to the implementation and development side of building AI solutions, AB-100 is strongly focused on: Solution architecture Business requirements Technology selection Microsoft Copilot Studio Dynamics 365 Choosing the right Microsoft technology for each scenario Here are my main takeaways. AB-100 Is an Architecture-Oriented Exam The most important thing to understand is that AB-100 is not a coding exam . I did not encounter any code-oriented questions. Instead, the exam focuses on your ability to analyse a business scenario and determine how a solution should be designed. The questions are closer to: Which Microsoft technology should the organisation use? When should a company choose one platform instead of another? How should different services and products be combined? Which solution best satisfies the business and technical requirements? What are the architectural consequences of each decision? Memorising individual product features is not enough. You need to understand how the different Microsoft technologies fit together, where they overlap, and why one option is more appropriate than another under specific circumstances. Dynamics 365 Knowledge Is Important A good understanding of Dynamics 365 is important for this exam. You do not necessarily need to be a specialist in every Dynamics 365 product, but you should understand the role of the platform within a broader business solution. You should be comfortable identifying situations where Dynamics 365 is a better choice than: Building a custom application Using only Power Apps Using standalone Azure services Creating a solution entirely from scratch The exam expects you to reason about complete organisational solutions, not just isolated AI capabilities. You Need to Understand Microsoft Copilot Stu

Hi everyone! This is my first HN and I’m very new to the scene. My name is Min from Bangkok. At first, I just want to create a dead man's switch for personal use and for fun. then, I think about information that self destruct like a spy movie. after that, I try to come up with the better version of Privnote or Bitwarden with self-destruct and some kind of censoring or blocking download ability. Somehow, end up with this product. :O Flashpaper is for sending any information that would be burned a

Container-Native AI: Mastering GPU Passthrough, Memory Limits, and Auto-Scaling for Your Agent Infrastructure Unlock peak performance for your AI agents by mastering container resource management. This guide details Docker AI configurations for GPU passthrough, precise memory limits, and dynamic auto-scaling of containerized agents to build robust, cost-efficient AI infrastructure. The Container Imperative for AI Workloads The promise of AI agents—autonomous systems that reason, plan, and execute—hinges on reliable, scalable infrastructure. Deploying these agents on traditional VMs or bare metal creates inefficiencies: dependency conflicts, inconsistent environments, and manual resource provisioning that can't keep pace with demand. Container AI solves this by packaging agent code, models, and dependencies into immutable images, ensuring perfect reproducibility from a developer's laptop to production. However, containerizing AI isn't as simple as `docker run`. High-performance agents require specialized hardware access, particularly GPUs for model inference. They also demand strict resource boundaries to prevent one agent from starving others and efficient scaling to handle variable workloads. This is where container-native AI infrastructure moves beyond basic virtualization. By leveraging Docker's advanced features and orchestration platforms like Kubernetes, you can build a production-grade environment where GPU access is seamless, resource usage is optimized, and your fleet of containerized agents scales automatically. GPU Passthrough: Unleashing Accelerator Performance in Docker The single greatest performance hurdle for containerized AI is granting direct access to the host's GPU. NVIDIA's Container Toolkit is the standard solution, providing the necessary drivers and runtime hooks. Proper configuration allows a container to see and use the GPU with near-native performance, critical for low-latency inference. The setup begins at the host level, where you instal

100 Days of Solana, Day 100 Where I started I'd built REST APIs for years but had never touched a blockchain, or written a line of Rust. The curiosity how blockchain works, started my curiosity. What I expected I came in with a Web2 instinct: tests exist to prove your code does what it's supposed to do. Write the function, write a test that calls it, watch it pass, move on. A "failing test" was something you fixed, not something you shipped on purpose. What changed my understanding The moment this cracked open was building the capstone: a small Anchor program called proof-of-ship that lets a wallet permanently record, on chain, that it shipped something. The rule is simple — one ship record per wallet, forever. The rule lives entirely in the account's seeds: seeds = [ b"ship" , builder .key () .as_ref ()], bump Each wallet's record lives at one deterministic address. Try to create a second one, and init refuses, because an account already exists there. I wrote two tests. The first proved the happy path: call ship() , fetch the record, confirm the name and builder match. The second test is the one that changed how I think about testing: it ( " only lets each wallet ship once " , async () => { let rejected = false ; try { await program . methods . ship ( " Second try " , " This should never land " ). rpc (); } catch ( _err ) { rejected = true ; } assert . isTrue ( rejected , " second ship should have been rejected " ); }); This test isn't checking for a bug. It's checking that a rule holds. There's no function in my program called preventDuplicateShip() . There's no if statement rejecting the second attempt. The rule "one ship per wallet" isn't enforced by logic I wrote — it's enforced by the Solana runtime itself, because the PDA's address already has data in it. My job wasn't to write the rejection. My job was to prove the rejection actually happens. What I understand now On Web2 systems I controlled the whole stack, so "does it work" mostly meant "does the happy pa

Processing 100MB PDFs in the Browser: The Performance Optimizations That Made TinyPDF Usable When I built TinyPDF ( https://tinypdf.cn/?utm_source=devto&utm_medium=blog&utm_campaign=performance_optimization&utm_content=devto_performance_2026-07-28 ), I had one hard rule: no backend. Everything had to run in the browser. No file uploads, no servers, no costs. Just drag, drop, compress, download. But when I tested the first version with a real portfolio—88MB, 45 pages, full of high-res images—it froze the tab for 12 seconds. Here's what I changed to get that down to 2 seconds, without losing any features. 1. Use Web Workers for PDF Parsing (Don't Block the Main Thread) The first mistake: I ran PDF.js parsing directly on the main thread. // ❌ Bad: Blocks UI while parsing const pdf = await pdfjsLib . getDocument ( arrayBuffer ). promise ; The fix: Offload everything to a Web Worker. The main thread only handles user input and progress updates. // ✅ Good: Web Worker does the heavy lifting // Main thread const worker = new Worker ( ' pdf-compressor.worker.js ' ); worker . postMessage ({ type : ' process ' , data : arrayBuffer , targetSizeMB : 2 }); worker . onmessage = ( e ) => { if ( e . data . type === ' progress ' ) updateProgress ( e . data . percent ); if ( e . data . type === ' done ' ) downloadBlob ( e . data . blob ); }; Result: Tab stays responsive even with 100MB files. 2. Stream Image Processing (Don't Load All Pages Into Memory) Second mistake: I loaded every page into memory at once before processing. For a 45-page portfolio, that's 45 full-res images in memory simultaneously. The fix: Process one page at a time, and stream results to the output blob incrementally. // ✅ Good: Process one page, free memory, repeat for ( let i = 1 ; i <= numPages ; i ++ ) { const page = await pdf . getPage ( i ); const viewport = page . getViewport ({ scale : 1 }); const canvas = document . createElement ( ' canvas ' ); canvas . width = viewport . width ; canvas . height = view

Rust web development just got more interesting. If you prefer a video version: A few days ago, I spoke with Carl Lerche and Julien Scholz about Topcoat , a new batteries-included framework for building full-stack reactive web applications with Rust. Now I have finally tried it myself. Topcoat comes from the ecosystem behind Tokio and Axum, but it aims to provide a very different experience: routing, server-side rendering, reactive components, UI tooling, asset bundling, and hot reload in one framework. A simple Topcoat application This is what a basic application looks like: use topcoat ::{ Result , router ::{ Router , RouterBuilderDiscoverExt , page }, view ::{ component , view }, }; #[tokio::main] async fn main () { topcoat :: start ( Router :: builder () .discover () .build ()) .await .unwrap (); } #[page( "/" )] async fn home () -> Result { view! { <! DOCTYPE html > < html > < body > hello ( name : "World" ) </ body > </ html > } } #[component] async fn hello ( name : & str ) -> Result { view! { < h1 > "Hello, " ( name ) "!" </ h1 > } } The syntax feels surprisingly familiar if you have used server-rendered frameworks before. Pages and components are written in Rust, while the view! macro keeps the HTML structure easy to understand. What surprised me My first experience was better than expected. The setup was simple, the basic example was actually basic, and the development server provided working hot reload. That last part may sound normal to JavaScript developers, but it makes a huge difference for the Rust developer experience. Topcoat includes or plans to support: Server-side rendering Reactive components Module-based routing Tailwind integration Reusable UI components Asset bundling Fonts and icons Cookies and sessions Database integrations The experience feels closer to frameworks such as Laravel, Django, Rails, or Next.js, while allowing developers to build the application in Rust. Is Topcoat ready for production? Topcoat is still at an early stage. Break

Why can't I just wear my AirPods in the pool?

After reporting better-than-expected Q2 results, PayPal said it remains focused on its AI-driven turnaround, but would consider a deal that creates more value for shareholders.