了解如何使用 GitHub Advanced Security 来保护你的项目。原文最早发表于 The GitHub Blog。
Learn how to secure your projects and keep them safe with GitHub Advanced Security. The post GitHub for Beginners: Getting started with GitHub security appeared first on The GitHub Blog.
Cloudflare 正在把高级 Client-Side Security 工具开放给所有用户，并加入新的级联式 AI 检测系统。通过结合图神经网络和 LLM，他们将误报率降低了高达 200 倍，同时还能捕捉更复杂的攻击。
2026-03-30We are opening our advanced Client-Side Security tools to all users, featuring a new cascading AI detection system. By combining graph neural networks and LLMs, we've reduced false positives by up to 200x while catching sophistic…
OpenAI 与 Gates Foundation 联合举办的工作坊。
AI for Disaster Response in Asia: OpenAI Workshop with Gates Foundation
Google 发布了 Agent Development Kit（ADK）for Java 1.0.0，带来 Google Maps grounding、内置 URL 抓取、跨框架协作的 Agent2Agent 协议，以及通过 App / Plugin 架构实现的全局日志、上下文压缩和 Human-in-the-Loop 工作流。还提供了基于 Firestore 和 Vertex AI 的 session 和 memory 服务。
Google has released version 1.0.0 of the Agent Development Kit (ADK) for Java, introducing powerful new features like Google Maps grounding, built-in URL fetching, and a standardized Agent2Agent protocol for cross-framework collaboration. The update enhances agent control through a new "App" and "Plugin" architecture, which allows for global logging, automated context window management via event compaction, and "Human-in-the-Loop" workflows for action confirmations. Additionally, the release provides robust session and memory services using Google Cloud integrations like Firestore and Vertex AI to manage long-term state and large data artifacts.
了解 STADLER 如何使用 ChatGPT 改造知识工作，为 650 名员工节省时间并提升生产力。
Learn how STADLER uses ChatGPT to transform knowledge work, saving time and accelerating productivity across 650 employees.
Workflows 现在会在仪表盘里以步骤图显示。这里介绍了我们如何把 TypeScript 代码翻译成工作流的可视化表达。
2026-03-27WorkflowsCloudflare WorkersDevelopersWorkflows are now visualized via step diagrams in the dashboard. Here’s how we translate your TypeScript code into a visual representation of the workflow. ...André VenceslauMia Malden
Containers 和 Sandboxes 现在支持通过 HTTP 直接连接到 Workers。你可以在容器里通过特定主机名调用 Workers 的函数和绑定，例如 KV 或 R2。所有 handler 都运行在 Workers runtime 中，位于容器沙箱之外。
Containers and Sandboxes now support connecting directly to Workers over HTTP. This allows you to call Workers functions and bindings, like KV or R2, from within the container at specific hostnames. Run Worker code Define an outbound handler to capture any HTTP request or use outboundByHost to capture requests to individual hostnames and IPs. export class MyApp extends Sandbox {} MyApp.outbound = async (request, env, ctx) => { // you can run arbitrary functions defined in your Worker on any HTTP request return await someWorkersFunction(request.body);}; MyApp.outboundByHost = { "my.worker": async (request, env, ctx) => { return await anotherFunction(request.body); },}; In this example, requests from the container to http://my.worker will run the function defined within outboundByHost, and any other HTTP requests will run the outbound handler. These handlers run entirely inside the Workers runtime, outside of the container sandbox. TLS support coming soonContainers and Sandboxes currently only intercept HTTP traffic. HTTPS interception is coming soon. This will enable using Workers as a transparent proxy for credential injection.Even though this is just using HTTP, traffic to Workers is secure and runs on the same machine as the container. If needed, you can also upgrade requests to TLS from the Worker itself. Access Workers bindings Each handler has access to env, so it can call any binding set in Wrangler config. Code inside the container makes a standard HTTP request to that hostname and the outbound Worker translates it into a binding call. export class MyApp extends Sandbox {} MyApp.outboundByHost = { "my.kv": async (request, env, ctx) => { const key = new URL(request.url).pathname.slice(1); const value = await env.KV.get(key); return new Response(value ?? "", { status: value ? 200 : 404 }); }, "my.r2": async (request, env, ctx) => { const key = new URL(request.url).pathname.slice(1); const object = await env.BUCKET.get(key); return new Response(object?.body ?? "", { status: object ? 200 : 404 }); },}; Now, from inside the container sandbox, curl http://my.kv/some-key will access Workers KV and curl http://my.r2/some-object will access R2. Access Durable Object state Use ctx.containerId to reference the container's automatically provisioned Durable Object. export class MyContainer extends Container {} MyContainer.outboundByHost = { "get-state.do": async (request, env, ctx) => { const id = env.MY_CONTAINER.idFromString(ctx.containerId); const stub = env.MY_CONTAINER.get(id); return stub.getStateForKey(request.body); },}; This provides an easy way to associate state with any container instance, and includes a built-in SQLite database. Get Started Today Upgrade to @cloudflare/containers version 0.2.0 or later, or @cloudflare/sandbox version 0.8.0 or later to use outbound Workers. Refer to Containers outbound traffic and Sandboxes outbound traffic for more details and examples.
看看 GitHub Actions 的 2026 路线图，了解 secure defaults、policy controls 和 CI/CD observability 如何端到端加固软件供应链。原文最早发表于 The GitHub Blog。
A look at GitHub Actions’ 2026 roadmap, outlining how secure defaults, policy controls, and CI/CD observability harden the software supply chain end to end. The post What’s coming to our GitHub Actions 2026 security roadmap appeared first on The GitHub Blog.
新的 secrets 配置属性允许你在 Wrangler 配置文件里声明 Worker 所需的 secret 名称。必需的 secrets 会在本地开发和部署时被校验，并作为类型生成的事实来源。
The new secrets configuration property lets you declare the secret names your Worker requires in your Wrangler configuration file. Required secrets are validated during local development and deploy, and used as the source of truth for type generation. wrangler.jsonc { "secrets": { "required": ["API_KEY", "DB_PASSWORD"], },} wrangler.toml [secrets]required = [ "API_KEY", "DB_PASSWORD" ] Local development When secrets is defined, wrangler dev and vite dev load only the keys listed in secrets.required from .dev.vars or .env/process.env. Additional keys in those files are excluded. If any required secrets are missing, a warning is logged listing the missing names. Type generation wrangler types generates typed bindings from secrets.required instead of inferring names from .dev.vars or .env. This lets you run type generation in CI or other environments where those files are not present. Per-environment secrets are supported — the aggregated Env type marks secrets that only appear in some environments as optional. Deploy wrangler deploy and wrangler versions upload validate that all secrets in secrets.required are configured on the Worker before the operation succeeds. If any required secrets are missing, the command fails with an error listing which secrets need to be set. For more information, refer to the secrets configuration property reference.
给社区一个地方，分享自定义指令、提示词和聊天模式，来定制 GitHub Copilot 的 AI 回复。我们原本以为每周能有一条贡献就不错了，结果完全超出预期。现在它又多了网站、学习中心和插件。
Back in July, we launched the Awesome GitHub Copilot Customizations repo with a simple goal: give the community a place to share custom instructions, prompts, and chat modes to customize the AI responses from GitHub Copilot. We were hoping for maybe one community contribution per week. That… did not happen. Instead, you all showed up. […] The post Awesome GitHub Copilot just got a website, and a learning hub, and plugins! appeared first on Microsoft for Developers.
AI coding agents 将深刻改变漏洞开发的方式和经济结构，甚至会自动发现零日漏洞。过去两年里，技术圈一直在警告 AI coding agents 可能会带来大量安全漏洞。
Thomas H. Ptacek / sockpuppet.org: AI coding agents will drastically alter both the practice and the economics of exploit development, automating the discovery of zero-day vulnerabilities — For the last two years, technologists have ominously predicted that AI coding agents will be responsible for a deluge of security vulnerabilities.
Rust coordinator 负责流量管理，Python worker 用基于 Python 的 DSL 执行规则逻辑，方便信任与安全团队在超大规模下做实时威胁缓解。作者：Patrick Farry
Discord open-sourced Osprey, a safety rules engine processing 400 million daily actions and 2.3 million rules per second. Osprey uses a polyglot architecture: a Rust coordinator manages traffic, while stateless Python workers execute logic using a Python-based domain-specific language called SML. This design allows trust and safety teams to deploy real-time threat mitigations at high scale. By Patrick Farry
加州州长 Gavin Newsom 签署了一项前所未有的行政令，要求与州政府签约的 AI 公司提供安全和隐私保护措施。
Cecilia Kang / New York Times: California Gov. Gavin Newsom signs a first-of-its-kind executive order requiring safety and privacy guardrails from AI companies that contract with the state — Gov. Gavin Newsom, a Democrat, issued an order requiring safety and privacy guardrails for artificial intelligence companies contracting with the state.
Soroosh Khodami 讨论了为什么我们还没准备好迎接下一个 Log4Shell。他通过依赖混淆和被篡改构建的现场演示，说明看似微小的疏忽如何让攻击者获得整个系统访问权，并解释了 SBOM、依赖防火墙和安全左移的重要性。
Soroosh Khodami discusses why we aren't ready for the next Log4Shell. He shares live demos of dependency confusion and compromised builds, explaining how minor oversights gift hackers total system access. He explains the value of Software Bill of Materials (SBOM), dependency firewalls, and shifting security left to build resilient DevSecOps cultures that protect the modern software supply chain. By Soroosh Khodami
Rec Room 这家西雅图的社交游戏公司曾在 2021 年 12 月估值 35 亿美元，如今宣布将在 6 月 1 日关闭平台，因为找不到盈利路径。
Todd Bishop / GeekWire: Social gaming startup Rec Room is shutting down its service on June 1, saying it could not find a path to profitability; it was valued at $3.5B in December 2021 — Rec Room, the Seattle-based social gaming company once valued at $3.5 billion, is shutting down its platform on June 1 …
Avraam Tolmidis
In this article, author Avraam Tolmidis discusses technical architecture of autonomous vehicles, with focus on optimization techniques like context-aware sensor fusion and Model Predictive Control (MPC) solvers to help with processing raw sensor data into safe control commands. By Avraam Tolmidis
David Sacks 在塑造特朗普 AI 议程中的新角色；官员称 Sriram Krishnan 将在国家经济委员会负责 AI。共和党内部对“全力押注 AI”越来越谨慎。
Axios: Inside David Sacks' new role shaping Trump's AI agenda; officials say Sriram Krishnan is taking on a position at the National Economic Council to focus on AI — - The move lands as Republicans grow increasingly wary of an all-in attitude on AI development and begin to question …
GraalVM Native Build Tools 1.0 和 EclipseLink 5.0 的 GA 版本、Open Liberty 2026 年 3 月版、Spring Boot / Spring Modulith / Spring AI 的第四个 milestone、Quarkus 的 point release、Infinispan 的首个开发版，以及 GlassFish 的维护更新。作者：Michael Redlich
This week's Java roundup for March 23rd, 2026, features news highlighting: GA releases of GraalVM Native Build Tools 1.0 and EclipseLink 5.0; the March 2026 edition of Open Liberty; fourth milestone releases of Spring Boot, Spring Modulith and Spring AI; a point release of Quarkus; the first development release of Infinispan; and a maintenance release of GlassFish. By Michael Redlich
优先级反转。本文用这个经典事故解释 RTOS 中的调度问题，以及为什么看似很小的锁和任务优先级配置，足以在生产系统里引发灾难。
Ask any seasoned embedded software developer what happened to NASA’s Mars Pathfinder in 1997, and you’ll almost certainly hear two words…Continue reading on Medium »
架构熵。没有严谨框架的快速生成，最后往往会把代码库搞得碎片化、难以维护。文章主张把重点从“输出代码”转向“定义规范”，也就是 Spec-Driven Development。
Recently, the term “vibe coding” has felt like a new shortcut in the world of software development. We simply type a prompt, and the code…Continue reading on Medium »
在前端开发过程中，功能细化是非常关键的一步，它能确保最终产品符合需求。文章围绕需求澄清、边界确认和交付对齐展开。
En el proceso de desarrollo frontend, el refinamiento funcional es una etapa crucial para asegurar que el producto final cumpla con las…Continue reading on Pragma »
许多工程师都把 Math.random() 当成 Java 里生成随机数的“省事按钮”。但它并不总是廉价的。本文拆解了这背后的性能成本，以及在高并发或高吞吐场景下更合适的替代方案。
As software engineers, we are often taught that Math.random() is the "easy button" for generating random numbers in Java. It’s convenient…Continue reading on Medium »
真正重要的不是写死路径，而是设计好 loop 让智能自然涌现。
Ask any computer science student to name the most important construct in programming. They might say recursion. Maybe functions. Perhaps the class hierarchy. Few would say the while loop. They'd be wrong. And in 2026, that mistake is getting expensive. The emergence of large language model-based autonomous agents has quietly elevated the while loop from a pedestrian control-flow primitive to the most consequential architectural unit in software engineering. Every meaningful autonomous agent — every AI system that perceives, reasons, acts, and adapts — runs, at its core, a loop. The loop is the architecture. This is not a metaphor. It is a structural reality with profound engineering consequences. Understanding it — truly understanding it — is what separates engineers who will build the defining systems of this decade from those who will inherit their technical debt. "The while loop is no longer a control-flow primitive. In the age of agents, it is a cognitive architecture." The Primitive Hiding in Plain Sight In classical software, loops are deterministic. A while loop iterates a list. A for loop counts to a fixed number. The programmer knows — or can know — how many times it executes, what state it produces, and when it terminates. Predictability is a virtue. Surprise is a bug. Agentic AI inverts this entirely. An autonomous agent — an LLM equipped with tools, memory, and the ability to act in the world — does not execute a predetermined sequence. It loops. It observes the environment, reasons about what it sees, selects from a potentially infinite action space, executes that action, examines the result, and loops again. The termination condition is not fixed at design time. The number of iterations is not known in advance. The path through the loop is not predictable, even by the agent itself. And yet — this is the remarkable part — good things happen. Tasks get done. Problems get solved. In ways that were never explicitly programmed. This is what emergence looks like in software. What Is Emergent Architecture? Emergent Architecture is a design philosophy in which the functional structure of an intelligent system is not statically defined but arises dynamically from the interaction of autonomous reasoning agents operating through iterative loops, guided by goals and constrained by policies. This is distinct from — and in direct tension with — traditional software architecture, where the structure is the design. In emergent architecture, the programmer doesn't specify what the system does. They specify: What the system wants (goals) What the system can do (tools and permissions) What the system cannot do (constraints and policies) The specific sequence of actions that results? That's discovered at runtime. It emerges. Emergent Architecture doesn't mean "architecture without design." It means designing the conditions under which good behavior emerges, rather than specifying the behavior directly. This is the critical intellectual move that distinguishes agentic software engineering from every prior paradigm. The Emergent Loop: Anatomy of an Agentic Mind The Emergent Loop is a generalization of several prior frameworks — Boyd's OODA loop, the PDCA cycle, control theory feedback loops. It extends these with two elements unique to LLM-based agents: a Reflect phase and a persistent, stratified Memory layer. Phase 01 — Observe: Perceive the environment via tools, APIs, memory retrievals. Selective attention is itself a reasoning task. Phase 02 — Orient: Synthesize observations with prior knowledge to build a belief state. The cognitive core — and the primary failure point. Phase 03 — Decide: Select the next action under uncertainty. When unsure, choose to gather more information rather than commit. Phase 04 — Act: Effect change in the world: call APIs, write files, execute code. Irreversible actions require extra validation loops. Phase 05 — Reflect: Evaluate: did that work? What changed? This phase is what creates in-task intelligence. Most frameworks skip it. Don't. Phase 06 — Memory: Update working, episodic, semantic, and procedural memory stores. Each iteration is a step of compounding knowledge. One phase deserves special emphasis: Reflect. It is what elevates the Emergent Loop above its predecessors. After each action, the agent asks: did that work? What did I learn? Do I need to revise my goal, plan, or beliefs about the world? This self-evaluation is not error-checking. It is the mechanism through which agents improve their performance within a single task execution, exhibit robustness to unexpected outcomes, and develop the capacity for meta-cognitive correction. Systems that skip the reflection phase are measurably less capable. Not slightly. Dramatically. The Code That Changed Everything Here is what agentic code actually looks like. Not a prompt. Not an API call. A loop: while (!goalSatisfied && budget.remaining()) { observation = agent.observe(availableTools, belief); belief = agent.orient(observation, memory, goal); action = agent.decide(belief, goal, constraints); result = executor.run(action); reflection = agent.reflect(action, result, goal); memory.update(reflection); goalSatisfied = agent.evaluate(memory, goal); } This is not abstract. This is the control flow running inside every meaningful agentic system today — from Claude's computer use, to GitHub Copilot's agent mode, to enterprise automation pipelines running on custom MCP orchestrators. Dimension Traditional Software Emergent Loop Behavior specification Fully in code Arises from reasoning Adaptability None Adapts to reality Termination Guaranteed Goal or budget condition Failure mode Crash Plausible-wrong answer Novel tasks Requires rewrite Generalizes naturally When Loops Talk to Loops: Multi-Agent Emergence Single-agent loops are impressive. Multi-agent loops are transformative. When multiple agents — each running their own Emergent Loop — interact through shared environments or message protocols, two things happen simultaneously: the system's capabilities grow superlinearly, and its failure modes grow more dangerous. The most powerful multi-agent pattern is the Critic-Generator loop: one agent generates outputs (plans, code, decisions) while a second evaluates them against quality criteria. The generator iterates based on the critic's feedback. This pattern works so well because it separates two cognitive modes that a single agent struggles to perform simultaneously — creative generation and rigorous evaluation. Another pattern worth understanding: emergent division of labor. In multi-agent systems with shared goals and differentiated tool access, specialization emerges without explicit programming. The agent with web-search tools becomes the researcher. The one with code-execution becomes the implementer. The one with read-only database access becomes the analyst. You didn't assign these roles. They crystallized from the loop. The Failure Modes You Need to Know The Emergent Loop's failures are qualitatively different from traditional software bugs. A crashed program is obviously broken. A looping agent confidently pursuing the wrong goal while producing plausible-looking outputs is far more dangerous — because it fails silently, and at scale. Infinite loops: The agent takes the same action repeatedly, unable to escape. Fix: action-hash deduplication, loop diversity monitors, mandatory escalation after N failed attempts. Goal drift: After many iterations, the agent optimizes for an intermediate sub-goal rather than the original objective. Fix: periodic goal re-grounding, multi-evaluator checks. Hallucinated observations: The agent "remembers" a tool result that was never actually returned. Fix: strict output provenance tracking, mandatory tool-call logging. Context window poisoning: Stale, contradictory observations accumulate and degrade reasoning quality. Fix: hierarchical context summarization, selective retention strategies. Cascade failures: In nested loops, an error in an inner agent's output corrupts the outer agent's belief state. Fix: output validation between agent layers, circuit-breaker patterns. 8 Engineering Principles for the Emergent Era Design the envelope, not the path. Specify what the agent cannot do, not what it should do. The behavior that emerges in the constrained space will be more robust than any pre-specified procedure. Treat Reflect as a first-class component. Reflection is not debugging — it is the mechanism of intelligence. Invest in reflection quality. Separate critic models. Structured reflection prompts. Match loop speed to action consequence. Observe and Orient can iterate rapidly. Act — especially irreversible actions — must slow down proportionally to blast radius. Build friction, not just filters. Agents have authority; never possession. Secrets and credentials must be fetched at the last moment inside tool implementations — never in the agent's context window. Zero-knowledge credential architecture is non-negotiable. Budget everything. Token budgets, cost ceilings, action counts, iteration limits. Every unconstrained resource in an agentic system is a runaway risk waiting to happen. Make the loop observable. Every iteration should emit a structured trace: what was observed, believed, decided, done, and reflected. This trace is your audit log in regulated environments. Human-in-the-loop is a loop, not a gate. Human oversight belongs inside the cycle as an escalation condition, not as a checkpoint before or after execution. Treat human judgment as a special-class tool call. Test outcomes, not paths. Emergent behavior is non-deterministic. Test for output quality, constraint satisfaction, and safety invariants across many stochastic runs — not specific action sequences. What Comes Next: Recursive Emergence We are in the earliest phase of emergent architecture. Current agentic systems are impressive but rudimentary — single-task executors with narrow tool sets. The trajectory is clear, and it leads somewhere genuinely new. The next frontier is agents whose Reflect phase produces not just revised plans, but revised strategies for planning. Agents that learn how to think, not just what to think about. This meta-learning capability — emerging from iterative self-reflection — is already visible in early research on self-play, constitutional AI training, and agent fine-tuning from execution traces. Beyond that: systems where the architecture itself is emergent. Agents that spawn, delegate to, terminate, and reorganize other agents based on task requirements. Systems whose structure — which agents exist, what tools they have, how they communicate — evolves through the operation of higher-order loops acting on the system's own design. "We are not programming intelligence. We are cultivating it. And like all cultivation, it requires understanding the nature of what grows, the conditions it needs, and the constraints that shape it toward human flourishing rather than away from it." Conclusion The while loop is the most important construct in the AI era. Not because it is technically complex — it is not. Because it is the architectural unit through which intelligence operates: iterative, adaptive, goal-directed, and emergent. Emergent Architecture asks us to set down the habit of specifying behavior and pick up the harder, more powerful habit of designing conditions. To trust that systems given good goals, good tools, good constraints, and good reflection mechanisms will discover good solutions — solutions we could not have specified in advance, for problems we could not have fully anticipated. The engineers who internalize this — who learn to think in loops rather than in procedures, in constraints rather than in scripts — will build the defining systems of the next decade. Build the loop. Understand the loop. Govern the loop. Everything else follows. References Yao et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. arXiv:2210.03629 Shinn et al. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. arXiv:2303.11366 Sumers et al. (2024). Cognitive Architectures for Language Agents. TMLR 2024. Park et al. (2023). Generative Agents: Interactive Simulacra of Human Behavior. ACM UIST. Anthropic (2024). Model Context Protocol. modelcontextprotocol.io Originally published on Medium. Cite as: Kajahussan, R. K. (2026). The While Loop at Scale: Emergent Architecture in the Agentic AI Era. March 2026.
代码手写时代正在成为过去。随着生成式 AI 更深入地进入开发流程，工程师的角色正在从“写代码”转向“编排架构”。作者主张用 Spec-Driven Development（SDD）来对抗 vibe coding 带来的架构熵，让工程师从实现者升级为架构师。
The Architectural Shift The era of writing code by hand is becoming a relic of the past. As we move deeper into the age of Generative AI, the role of the software engineer is undergoing a fundamental phase shift: from the depth of manual syntax to the breadth of architectural orchestration. The Entropy of "Vibe Coding" "Vibe coding"—relying on AI to generate code based on loose prompts and "vibes"—is an excellent entry point, but it carries a hidden tax: architectural entropy. Without a rigorous framework, rapid AI generation leads to inconsistencies, technical drift, and a fragmented codebase that no human brain can fully map. Enter Spec-Driven Development (SDD) Spec-Driven Development is the "all-in" solution to AI-driven engineering. It shifts the focus from the output (the code) to the intent (the specification). The Engineer as Architect: In SDD, writing code is the simplest and fastest part of the cycle. The real work happens in refining the "spec"—ensuring requirements are precise, edge cases are covered, and external dependencies are identified upfront. Contextual Superiority: While a human engineer will inevitably miss details in a massive project, GenAI can hold the entire context in memory. By using SDD, the engineer acts as a high-level validator, challenging assumptions and directing the AI to maintain a consistent vision. The End of the Jira Bug Cycle: In an SDD workflow, the feedback loop is nearly instantaneous. Instead of an architect writing a spec and waiting weeks for a developer to validate it, the "newborn architect" (formerly the developer) can validate assumptions on the spot. The Economics of Hyper-Productivity The transition to SDD isn't just a qualitative win; it’s a massive economic lever. In a recent month-long experiment with Spec-driven development, I burned through over 1,000% of my monthly token allowance. The cost? $135. To put that in perspective: Metric Delta Direct Cost ~$135 (Roughly one hour of a mid-level developer's time) Output Volume Equivalent to 3 months of full-time manual engineering Quality Control Precision bug identification exceeding manual capacity The Path Forward: Breadth Over Depth There will be resistance. Engineers who have spent years perfecting their manual craft may feel marginalized. However, the argument is not that these skills are obsolete, but that they must be elevated. We are moving toward a world where every pull request is a spec. The goal is to turn every developer into an architect—someone who understands the entire picture, manages dependencies, and leverages AI to execute with a speed and accuracy that was previously impossible. The conclusion is clear: Writing code by hand is becoming "lame." The future belongs to those who can master the specification.
https://x.com/ggerganov/status/2038632534414680223 https://github.com/ggml-org/llama.cpp
https://x.com/ggerganov/status/2038632534414680223 https://github.com/ggml-org/llama.cpp
我是 Jianyang Gao，RaBitQ 论文的第一作者。我在这里发帖，是因为 TurboQuant 现在正在 r/LocalLLaMA 里被讨论，大家把它放在本地推理 / KV-cache 压缩的语境里，我觉得社区应该看到一个更…
I am Jianyang Gao, first author of the RaBitQ papers. I am posting this here because TurboQuant is now being discussed in \r/LocalLLaMA\ in the context of local inference / KV-cache compression, and I think the community should have a te…
据说 Google…
Openreview: https://openreview.net/forum?id=tO3ASKZlok It's sad to see almost no one mention this on Reddit and people are being mean to people who point out concerns Edit: google is allegedly…
Meta/PyTorch 的 Daniel Vega-Myhre 发了一篇新博文，讲解 FP8 的 GEMM 设计，并深入拆解 MXFP8 带来的约束与设计挑战。
New blog post by Daniel Vega-Myhre (Meta/PyTorch) illustrating GEMM design for FP8, including deep-dives into all the constraints and design challenges introduced by MXFP8. Link: https://danielvegamyhre.github.io/2026/03/29/mxfp8-gemm.html…
世界模型才是现在 AI 真正的主角。
Was at Nvidia's GTC conference recently and honestly, it was one of the most eye-opening events I've attended in a while. There was a lot to unpack, but my single biggest takeaway was this: world modelling is the actual GOAT of AI right no…
先给很高的额度把你套进去，等工作流锁定后再收紧限制。文章把这种模式拆成“补贴、上瘾、榨取”的路径。
Anthropic just ran the classic platform playbook on developers: offer generous limits to build dependency, then tighten the screws once the workflow is locked in. Their Spring Break promotion doubled off-peak limits for two weeks. It expir…
Join 并不贵
Joins are NOT Expensive
Mercury 的生产工程实践
A Couple Million Lines of Haskell: Production Engineering at Mercury
我是认真的，我们得采取行动了。我在这个 subreddit 里看到的每一条帖子，几乎全都是 AI 生成的项目展示。发帖的人通常会连帖子正文、应用、回复一起生成。
I'm being serious, we need to take action against this. Every single post I've gotten in my feed from this subreddit has been an entirely AI generated project showcase. The posters usually generate the entire post, the app, their replies t…
对我来说是 httpx。我以前很多年都只用 requests，从没觉得有问题。后来因为一个项目改成 httpx 用 async 支持，现在再回去就像回到 Python 2 一样。
for me it's httpx. i was using requests for literally everything for years and never thought about it. switched to httpx for async support on a project and now requests feels like going back to python 2. also pydantic v2. i know it's been…
VibeVoice 是一组**开源前沿语音 AI 模型**，同时包含文本转语音（TTS）和自动语音识别（ASR）模型。
VibeVoice is a **family of open-source frontier voice AI models** that includes both Text-to-Speech (TTS) and Automatic Speech Recognition (ASR) models.
从输入代码，升级到编排 agent、hooks、skills 和 MCP servers。
Go from typing to orchestrating agents, hooks, skills, and MCP servers — with visual tutorials, copy-paste templates, and a guided learning path.
Boris Cherny 在 X 上分享的几条实践帖。
Boris Cherny on X ( tweet 1 · tweet 2 · tweet 3 )
只需要一张图片，就能完成实时换脸和一键视频 deepfake。
Real-time face swap and video deepfake with a single click and only a single image.
OpenBB 的 Open Data Platform（ODP）是一套开源工具集，帮助数据工程师把专有、授权和公开数据源接入 AI 副驾驶和研究看板等下游应用。
Open Data Platform by OpenBB (ODP) is the open-source toolset that helps data engineers integrate proprietary, licensed, and public data sources into downstream applications like AI copilots and research dashboards.
freeCodeCamp.org 是一个友好的社区，你可以在这里免费学编程。
freeCodeCamp.org is a friendly community where you can learn to code for free.
可跨 400+ 社交网络按用户名搜索账号，并提供 Debian、Ubuntu、Homebrew、Kali、BlackArch 等社区维护包。
Hunt down social media accounts by username across 400+ social networks Community-maintained packages are available for Debian (>= 13), Ubuntu (>= 22.10), Homebrew, Kali, and BlackArch.
一款现代、面向企业的商业智能 Web 应用。
A modern, enterprise-ready business intelligence web application.
Fastfetch 是一款类似 neofetch 的工具，用于获取系统信息并以更美观的方式展示。
Fastfetch is a neofetch-like tool for fetching system information and displaying it in a visually appealing way.
**Nous Research 打造的自我改进型 AI agent。** 它带有内置学习循环，会从经验中创建 skills，在使用中持续改进，主动记住知识，搜索历史对话，并逐步建立对你的理解…
**The self-improving AI agent built by Nous Research.** It's the only agent with a built-in learning loop — it creates skills from experience, improves them during use, nudges itself to persist knowledge, searches its own past conversations, and builds a deepening model of who yo…