NetworkManager Adopts Policy For AI Coding Assistants

NetworkManager now permits AI coding assistance but makes the human author responsible for every line: authors must understand, build, test, explain, and legally certify their patches. Commit messages and merge-request descriptions must be written by the contributor, and large machine-generated changes without line-by-line review will be closed.

That is a practical policy rather than a blanket ban. It preserves tool use while keeping authorship, review communication, licensing, and operational accountability with the person submitting the patch.

• NetworkManager policy change
• Source comments

Linux 7.2-rc7 Addresses a “Nasty” Race Condition Leading to Use-After-Free After 8 Years

Linux 7.2-rc7 fixes an eight-year-old race between the page-table dumper and vmap page-table freeing. A ptdump walker could continue through a PUD, PMD, or PTE page-table page after it had been freed, creating a use-after-free; Syzbot found the defect in June.

The fix was reworked from an investigation assisted by Claude Opus 4.8, then merged for the release candidate and expected to be backported to stable kernels. It is a useful example of AI-assisted debugging ending in a conventional, reviewable kernel patch rather than machine-authored code being trusted wholesale.

• Patch commit
• Source comments

Super Mario Derivations

Nix’s lazy attribute sets can encode a game’s input history as a derivation graph: each button press becomes a derivation whose input is the previous frame’s savestate. The Nix store then acts as a content-addressed, branchable emulator history—branching from a hundred-press run costs only the new press, and assembling a recording just links the already-built frames.

The experiment is a precise demonstration of why Nix’s laziness and store model are more general than package catalogs. It also exposes practical limits: evaluation is linear in the input sequence, command-line argument size caps long runs, and substituter round trips can cost more than emulation.

• Implementation
• Lobsters discussion

The Nixpkgs core team has disbanded

Nixpkgs’ delegated core team has dissolved after ten months, saying the governance role became incompatible with sustained technical contribution and was harming members’ health. The team reports concrete progress—19 new committers, merge-bot improvements, security triage, and an initial automation/AI policy—but says recruitment and the relationship with the Steering Committee became unsustainable.

The post is unusually candid about the failure mode: a top-level committee that micromanages delegated teams while communicating inconsistently leaves technical owners without clear authority. The team is stepping back rather than seeking Steering Committee seats, leaving the committee as the immediate backstop.

• Announcement and discussion
• NixOS organization change

A shell exclamation mark is not for yelling. Be lazy.

Bash, zsh, and csh event designators let you reuse a command’s event, words, and modifiers without repeatedly editing history: sudo !!, !:2*, !$:h, and !ssh:p cover many common cases. The article also explains POSIX fc, which provides editor-backed history editing and substitution even when ! expansion is unavailable.

This is interactive-shell technique, not script advice: history expansion can surprise you, so the article also shows how to disable it. The useful takeaway is a compact vocabulary for reusing paths, flags, and arguments without arrow-key archaeology.

• Lobsters discussion
• Bash event designators

Linux 7.2-rc7 Restores Btrfs Fixup Workers to Address Silent Data Loss

Linux 7.2 briefly removed Btrfs’s copy-on-write fixup mechanism under the assumption that newer memory-management behavior made it unnecessary. That assumption was wrong: dirty pages without an ordered extent could escape the filesystem’s COW handling and cause silent data loss. The fixup worker infrastructure—more than 600 lines, including updated folio and subpage support—has been restored for rc7.

This is a reminder that filesystem correctness mechanisms often encode assumptions that are difficult to see from adjacent MM changes. The restoration also includes fixes for an encoded-ioctl leak and unsafe large-folio configurations.

• Btrfs pull request
• Source comments

AMD ROCm Spur: Providing AI-Native, Rust-Based Job Scheduling

AMD’s ROCm stack now includes Spur, an Apache-2.0 Rust scheduler aimed at multi-thousand-GPU clusters. It combines GPU-first scheduling, WireGuard mesh networking, restart-safe state, and drop-in compatibility with Slurm’s CLI, REST API, and C FFI; AMD also plans to use it on large CPU fleets.

The interesting part is the compatibility strategy: a new scheduler can offer modern cluster behavior without forcing existing Slurm integrations to be rewritten. The project is still an announcement, so production scale and operational differences remain to be demonstrated.

• ROCm/Spur source
• Source comments

Zapscape Is the Latest Linux Vulnerability for KVM Guest-to-Host Escape

Zapscape is a six-year-old use-after-free in KVM’s x86 shadow-MMU emulation that lets a guest escape to the host and execute as root. On systems where /dev/kvm is world-writable, including some RHEL configurations, the same bug can act as a local privilege escalation without a guest.

The vulnerable code was fixed on 21 July by checking for an invalid or obsolete root after MMU pages become available. A public, non-weaponized proof of concept is available, so KVM operators should verify that their host kernels include the fix rather than relying only on guest isolation.

• Zapscape proof of concept
• Source comments

The valley of webhooks

Webhooks are a poor replication protocol: they are unordered, at-least-once notifications, so every consumer rebuilds ordering, deduplication, bootstrap, retries, and reconciliation around a stream that can silently lose deletes. Weli proposes SCROLL (Synchronized Change Replication Over Line Logs): a provider-served, cursor-addressed log of full-state events that supports both resumable polling and a long-lived GET stream.

With one feed, bootstrap and live sync share a code path, tombstones make deletes explicit, replays are harmless upserts, and a checkpoint count/checksum can verify the local replica. Hacker News commenters connected the design to Braid-HTTP Subscriptions and Svix’s FIFO/polling/streaming products, while noting the hard parts are adoption, provider sequencing, and the extra lag or traffic of polling.

• Source discussion
• SCROLL draft

Delaunay32

Delaunay32 is a C++17 library for exact, parallel 2D Delaunay triangulation over signed 32-bit integer coordinates. It supports constraints, polygon domains with holes, deterministic duplicate handling, explicit float-to-integer quantization, and serial or shared-memory parallel execution. The author reports roughly 147–150 ms single-threaded and 53–54 ms eight-threaded for one million points on an Apple M1, versus about 540–555 ms for delaunator-cpp and slower results for Triangle and Fade2D.

The Hacker News discussion focused on the useful constrained-Delaunay support and comparisons with Triangle, plus why the API stops at int32: exact incircle predicates already need 128-bit intermediates, while int64 inputs would require roughly 256-bit temporaries. The project is MIT-licensed and includes benchmarks, tests, examples, and SVG/JSON extras.

• Source discussion

The next chapter of our AI momentum

Google is reshuffling its AI leadership: Demis Hassabis moves from day-to-day leadership of Google DeepMind to Chair and Alphabet Chief Scientist, Koray Kavukcuoglu becomes SVP of Google DeepMind with Gemini and frontier research reporting to Sundar Pichai, and Jeff Dean and Sanjay Ghemawat are leaving to found the public-benefit Discovery Loop, with Google as investor and cloud partner.

The announcement frames this as freeing Hassabis to focus on AGI, science, and Isomorphic Labs while tightening operational ownership of Gemini. Hacker News discussion is split between reading the move as a research-oriented scientist stepping into a broader technical role and as a face-saving step away from product control; the common thread is that Dean and Ghemawat’s departure, alongside other recent exits, signals a meaningful change in Google’s research culture.

• Source discussion

DeltaDB — Early Access

Zed is previewing an operation-level version-control system that records every change between commits, links edits to the agent conversation that produced them, and treats any point in a virtualized worktree as a branch point. The goal is to make the live conversation and code a shared, addressable artifact rather than reconstructing intent later from commits and pull-request threads.

The design combines fine-grained deltas, conflict-free replicated worktrees, and persistent conversation/code links; Git and CI remain useful for snapshots and integration. Hacker News readers compared it with JetBrains Local History and the Linux kernel’s mailing-list-plus-Git workflow, while also raising concerns about privacy, storage, and whether another collaboration layer is worth the complexity.

• Source discussion

NVIDIA’s Vera Whitepaper Has a Thread Loose

Chips and Cheese finds NVIDIA’s first in-house server CPU, Vera, genuinely strong hardware but a much weaker competitive narrative. The 88-core Olympus Arm design has a 10-wide front end, value prediction, graph prefetching, large caches, and up to 1.2 TB/s of LPDDR5X bandwidth; early independent tests suggest formidable per-core performance.

The whitepaper’s comparisons are less convincing: it caricatures conventional SMT, treats an optional 32-node EPYC NUMA layout as the norm, calls ordinary SPEC programs “agentic benchmarks,” compares undefined cross-ISA counters, and presents an RL chart without enough methodology to reproduce it. The authors’ own Turin measurements also reduce NVIDIA’s claimed memory-bandwidth lead from nearly 3× to roughly 1.9×. Readers broadly agreed that open, unrestricted production testing should decide the question.

• Source discussion

Introducing Muse Code and Muse Spark 1.2

Meta’s Muse Code beta is a terminal coding agent built around Muse Spark 1.2. Its notable engineering choices are persistent asynchronous subagents, a local append-only event log for replay-exact crash recovery, approval-gated skills such as /plan and /grill, and co-training the model with the harness’s trajectories, compaction, goals, and subagent tooling.

Meta reports long-horizon coding runs exceeding 1,000 tool calls and up to 24 hours, including iterative Triton GPU-kernel optimization. Muse Code is available for macOS and Linux, while Spark 1.2 is exposed through Meta’s model API.

The release is interesting primarily as a harness-design document, not just a model announcement: the runtime, recovery semantics, and tool compatibility are treated as part of model quality. HN commenters liked the event-log and persistent-worker ideas but questioned the selective benchmark comparisons, the closed source, the rough beta experience, and Meta’s data-sharing terms. Several users also reported that the discounted contributor pricing is limited by region and requires allowing Meta to use request data for product improvement.

• Hacker News discussion

How Castform + Neon Beats Frontier Models on Price and Efficiency

Castform post-trained a 4B open model to retrieve answers from a company corpus as accurately as GPT-5.6 Sol on its test, while claiming roughly 100× lower inference cost. The recipe turns existing documents into synthetic questions and answers, trains an agent to use hybrid BM25/vector search, and scores retrieval, citation, and final-answer correctness in the loop.

The useful idea is less the headline benchmark than the decomposition: retrieval quality is a model problem as well as a database problem, and proprietary documentation can supply training tasks without a hand-built labeled dataset. Neon provides the Postgres/Lakebase Search environment and branching/autoscaling for parallel rollouts; Castform supplies the post-training loop.

The caveats matter. The evaluation uses a GitLab handbook corpus, not a broad independent benchmark; the authors acknowledge data drift and say training cost was under $200 for the experiment. HN commenters also asked for total-cost break-even analysis, larger and messier corpora, and comparisons with cheaper models such as DeepSeek Flash.

• Hacker News discussion
• Open-source benchmark example

Discovery Loop: Continuous Exploration

Discovery Loop is a new effort from Jeff Dean, Sanjay Ghemawat, Quoc Le, and Oriol Vinyals to automate scientific and engineering experiment loops: propose, run, evaluate, and iterate thousands of times in parallel. It starts with machine-learning research and aims to extend the same machinery to measurable problems across science and engineering.

The impressive part is the team’s full-stack scale, from chips and infrastructure through models and products. The caveat is that automation does not remove domain expertise, physical-experiment latency, or funding and deployment bottlenecks; the ambitious “any learning loop” claim is still a mission statement.

HN discussion was split between excitement about the founding team and skepticism that biological and physical discovery can be reduced to fast computational loops. Several commenters compared the idea with Karpathy-style autoresearch and argued that scientists, labs, and experimental access remain the hard constraints.

• Hacker News discussion

HyperProbe: Agents that do read-only debugging in prod

HyperProbe lets a coding agent place bounded, read-only probes in a live Node, Python, or Java service, then capture variable snapshots across the call stack when real traffic reaches the line. It aims to replace the slow add-a-log, redeploy, reproduce cycle—especially for silent logic failures that ordinary exception and trace systems never record.

The design is deliberately constrained: in-process redaction, no writes, hit/expiry/token-bucket budgets, size and depth caps, network limits, and automatic suspension when probe overhead exceeds a threshold. The team reports roughly 7–10 ms active-probe overhead in Node, 4–9 ms in Python, and 1–2 ms in Java; idle probes are intended to have negligible cost. You can self-host the server, broker, and database.

HN commenters liked the hypothesis-driven debugging model but raised the important counterpoints: mature observability already handles many failures, a single snapshot can mislead, and audit trails are still on the roadmap. The authors say the agent should treat snapshots as evidence for testing hypotheses, not as an infallible diagnosis.

• Hacker News discussion