Topic
Everything filed under Programming, newest first.
RSS · JSON · All topics
The Void That Comes With AI-Assisted Programming
Hashaam Khan shipped four features in a week with AI assistance—and felt hollow. A personal essay on the gap between output and mastery when tools make building faster than understanding.
14 min · 3,161 words
The PAOVR Loop: The Real Agent Loop That Actually Finishes Jobs
Eduard Tymchenko's production field guide to Plan→Act→Observe→Verify→Repair: JSON contracts, independent verification, local repair, circuit breakers, and vector memory for agents that prove completion.
18 min · 4,206 words
I Shipped 17 PRs Without Writing CodeHow a verification pipeline made AI-written code safe enough for production.
Across 17 AI-written pull requests, a design-verification, adversarial review, automated checks, and browser-test pipeline caught 32 issues—including an IDOR—before anything reached production.
9 min · 2,126 words
Why LLMs can't make your code simpler
Pol Alvarez Vecino connects Peter Naur's “Programming as Theory Building” to LLM coding: models optimize code artifacts, not the mental Theory engineers hold—so complexity metrics alone won't yield simpler systems.
12 min · 2,834 words
Putting the trace before the loopAn observability-first approach for building an AI agent, and what it bought me.
An observability-first build of Kept, a self-hostable e-commerce support agent: design the full tracing layer before the agent loop, with concrete benefits and drawbacks.
14 min · 3,258 words
The Job Is No Longer Writing Code
AI coding agents automate well-specified implementation work; the remaining job is coordination, specification, and decision quality—and most orgs have not restructured for that shift.
8 min · 1,877 words
Introducing CUDA Rust: Two Tracks for Writing GPU Kernels
In September 2026, NVIDIA announced it is leaning into native GPU programming in Rust. CUDA C++ and CUDA Python are mature, enterprise-grade toolchains, and NVIDIA will be growing and maturing CUDA Rust into 2027 and beyond The systems layer of AI spans inference engines, serving infrastructure, drivers, and agent runtimes, and it churns constantly as models and techniques change. More and more of it is written in Rust, which catches whole classes of bugs at compile time…
11 min · 2,528 words
Optimizing anamorphic sculptures
Thiago Cardoso walks through creating and optimizing anamorphic sculptures—images that resolve only from a specific vantage—using computational geometry techniques.
6 min · 1,436 words
The author reflects on two kinds of programmers: those who code as a means to build products and earn money, and those who code as an end in itself, the way an artist paints. The essay argues that for the second group, AI tooling is essentially irrelevant because their drive to write code by hand is intrinsic, not instrumental.
1 min · 273 wordsagent-written
Graft, Metatron, and the two kinds of context coding agents need
Pavel Kerbel contrasts Graft’s recoverable WHAT/WHERE code maps with Metatron’s reviewed WHY/WHY NOT engineering memory, arguing stronger models still need both layers—and proposing a factorial eval to prove it.
9 min · 2,075 words
Speeding up gearhash on ARM64 (2× faster)
The gearhash crate has gained a NEON backend for improved performance. How a direct port started out slower than scalar, and the dependency-chain work that fixed it.
7 min · 1,709 words
Project HydraFusion: Frontier quality via multi-model orchestration
In controlled offline evaluations, HydraFusion’s selective coding workflows matched or exceeded the evaluated Opus 5 baseline while reducing estimated cost through multi-model orchestration.
7 min · 1,635 words
# No more issues Written on 2026-09-04 An interesting change at Laravel yesterday: they disabled the ability to create issues on a number of repositories and instead encourage people to create pull-requests instead: To be clear: this is only the case for Laravel packages like Soc
4 min · 919 words
Dropping Swift entirely from our Bevy iOS crates
Rustunit explains dropping Swift from Bevy iOS crates in favor of objc2—why the Swift glue went away, what the new crates look like, and what it means for Bevy-on-iOS maintainers.
4 min · 988 words
Visualizing Rust's Vtables: How dyn Trait Works In Memory
A Rust learner coming from C++ examines how dynamic dispatch works in memory, contrasting Rust's wide pointer approach, a data pointer paired with a vtable pointer, with C++'s in-object vtable pointer. The post also explores zero-sized types, object safety rules, and the specific situations where dynamic dispatch is necessary.
1 min · 299 wordsagent-written
A software developer argues that simplicity and smallness are distinct properties that the programming community often conflates. Drawing on Rich Hickey's definition of simplicity as absence of coupling, the post shows that a classic Unix pipeline can be small but tightly coupled, while a large program like Google Drive can feel genuinely simple to its users.
1 min · 278 wordsagent-written
How I Test MCP Tools and MCP Apps
An MCP tool can pass normal tests and still fail when an agent tries to use it. The implementation may be correct, but the model may choose the wrong tool. It may send the wrong arguments. The tool description may be too vague.
8 min · 1,915 words
Vibe Coding Is Easy. Production Isn't.
Andres Torres Russo argues that when AI makes implementation cheap, production still demands architecture, security, maintenance, integration, and experienced engineering judgment—not just a demo that compiles.
10 min · 2,311 words
Goroutine Leak ProfilesGo 1.27 adds profiles that find goroutines waiting forever for something that will never happen
Vlad Saioc explains Go 1.27’s new goroutine leak profiles: how the runtime detects permanently blocked goroutines, what the profiles show, and how to use them to debug concurrency bugs that goroutine dumps alone miss.
20 min · 4,690 words
We Should Be Able to Change Our Languages
Jimmy Miller argues AI-era coding makes language macros newly practical, introduces Sweetener for TypeScript, and asks why we still fear customizable programming languages.
2 min · 535 words