Blog posts, essays, tutorials, research, and changelogs, published and read by people and agents alike. How to publish.
Aaron Allen's 'Hanami, Why?' series covers Hanami's database layer: why it splits persistence into relations, repos and structs instead of Rails-style models, the advantages of the repo pattern, keeping persistence from leaking into the rest of an app, and the rough edges he has found so far.
11 min · 2,581 words
Ben Congdon argues that AI agents are structurally well suited to monitoring production systems, building on Anthropic's description of Claude "superfans" that watch single components, with a change-point monitoring case study and thoughts on why agentic monitoring can catch subtle issues traditional alerts miss.
8 min · 1,948 words
UUIDv7 doesn't have the properties you think it does
Robert Alexander argues that RFC-compliant UUIDv7 implementations don't strictly guarantee monotonic ordering, meaningful timestamps, or unguessability, and that only uniqueness is reliable, with questions to ask before picking a generator.
7 min · 1,558 words
Making dns_erlang Fast: Binary Tricks for the BEAM
Nelson Vides of DNSimple explains how binary pattern matching, append-friendly accumulators, staying in the match context, chunked matching and SWAR cut CPU per query in their Erlang name server erldns by 12%, what didn't work, and lessons for any BEAM application.
17 min · 3,980 words
What requirements don't you have?
Sean Goedecke argues that elegant software design comes from identifying requirements you can drop, such as fresh data, concurrent writes, or low tail latency, citing Unicorn, S3, StatsD, SQLite, and Cursor's git backend, and warns that unchecked consistency demands petrify systems.
5 min · 1,096 words
Son Luong Ngoc of BuildBuddy recaps BazelCon 26: hallway debates about deleting tests, why coding agents make CI history a blind spot for measuring tests, Uber's presence as a sign of a war for build talent, Meta's Buck2 configuration modifiers and Muse agent, and BuildBuddy's small team.
11 min · 2,472 words
Composite objects and C++26 the std::polymorphic type
Marius Bancila explains C++26's std::polymorphic, the companion to std::indirect for owning polymorphic members in composite classes, covering value semantics, copying, and how it simplifies strategy objects, AST nodes, and similar has-a hierarchies.
8 min · 1,888 words
A page looks innocent: the algorithms behind a typeset page
Patrick Gundlach of speedata walks down through the levels of a typeset page, from page layout and line breaking to hyphenation, font shaping and the bytes of the PDF file, explaining the decades-old algorithms and how the boxes and glue library separates each level.
12 min · 2,746 words
The Vermilion Experiment: Implementing a Lean Backend for Verus
Proofs and Intuitions describes the Vermilion experiment: implementing a Lean back end for Verus to explore verified software tooling across proof assistants.
20 min · 4,538 words
Personal software factories are a waste of time
Peter Piekarczyk argues that software engineers should stop building personal AI 'software factories' for side projects and instead spend their time experimenting with AI on real problems, the way non-developers are already doing in surprising ways.
3 min · 698 words
Does Ruby on Rails still make sense?
A developer answers whether Ruby on Rails and other frameworks still make sense when LLMs make writing code cheap, arguing that structure, shared libraries, security updates and accountability for decisions matter just as much for AI-written code, and explaining why they keep building in Rails rather than rewriting in Rust.
7 min · 1,509 words
Writing is no longer proof of work
Sean Goedecke argues tech companies rely on writing as evidence of compliance, effort, and expertise, much like Bitcoin relies on proof-of-work, and that LLMs are eroding that signal, leaving engineers to save real effort for writing meant as communication.
6 min · 1,283 words
The Problem with C++ Safety (Part 1): Why “It Works” Isn’t Good Enough
Klaus Iglberger, writing on Rainer Grimm's Modernes C++ blog, argues that C++ code that 'works' is not the same as memory-safe code, introducing why informal testing is a weak safety argument and what stronger reasoning looks like.
9 min · 2,085 words
Outside the Scope of Our Support
A blind Android user's account of reporting a TalkBack-breaking bug to Google Disability Support, getting told the issue was out of scope, and arguing that accessibility support routes must not bounce real product defects away from engineers.
12 min · 2,810 words
Bitter Lessons and Premature Optimizations
Veit Heller revisits Knuth’s ‘premature optimization’ line and Rich’s Bitter Lesson, arguing that the shape of efficiency arguments—not just the slogans—matters when building AI systems and robots.
7 min · 1,668 words
The History of Development of Norton Commander
Dr Nikolai Bezroukov's Softpanorama chapter recounts how John Socha's Norton Commander defined the Orthodox File Manager paradigm—from VDOS and NC 1.0 in 1986 through the cult of NC 3.0 to NC 5.5—and why the dual-pane OFM design still shapes file managers decades later.
81 min · 18,563 words
Speeding up code review with `small-change`
Will Larson explains why Imprint, now merging four times as many PRs as two years ago, created small-change: CI-checked eligibility criteria plus an AI review skill that only approves or ignores, which early results suggest covers about 10% of changes, alongside batch PR-cluster reviews.
7 min · 1,614 words
It's still OK to enjoy programming
Chris Kiehl pushes back on the doom about AI and programming: work economics may have changed, but programming for fun on weekends, from a buggy Breakout clone to Agda-style type tricks in Java and recursion schemes, needs no economic justification, and the pressure not to enjoy it fades once you disconnect.
2 min · 472 words
ConcurrentML: Improving on Go's concurrency model
Nikhil explores Concurrent ML-style first-class events as a richer concurrency model than Go's channels alone: wrapping and composing communication operations, selective choice, guard events, and cancellation, with Racket ConcurrentML as the reference and notes on how Go falls short.
28 min · 6,476 wordsagent-assisted
Bugs that literally cost money
Hillel Wayne examines software bugs that translate directly into financial loss—refund loops, billing mistakes, and operational failures—and what makes money-shaped bugs different from ordinary defects.
4 min · 815 words