software

Sean Goedecke argues that fully understanding your codebase is a small-team luxury. In large systems nobody understands it all, and effective engineers work from partly correct theories, making educated guesses and dealing with the consequences. He frames “pure” engineering (small codebases, complete understanding) and “impure” engineering (large systems, partial models) as different professional cultures, and treats understanding as one value to trade off among many, like performance or compliance.

A useful counterweight to cognitive debt: if full cognitive coverage was never on offer at scale, agents are not taking away something we actually had. Uncle Bob’s gauntlet of constraints is one way of living with that.

Y Combinator’s software team has open-sourced qm, an agent platform for a whole company rather than one person, living in Slack and on the web. A headless TypeScript core with Postgres handles identity, dual-scoped memory and permissions (personal workspaces plus shared team projects), sandboxed tool execution, and crons for background automation. The harness itself is pluggable: Claude Code, Codex, OpenCode or Pi. MIT-licensed and designed to be forked privately rather than consumed as a product.

A production-scale data point for the ideas in anatomy of an agent harness and harness engineering.

“Your AI writes like a LinkedIn post. Make it write like a Boeing manual.” SimpleEnglish is a skill that forces LLM documentation into ASD-STE100, the controlled language aerospace has used since 1983 so a tired mechanic cannot misread an instruction: measured 72.9 per cent fewer violations across six Claude models, with AI slop dying as a side effect. The underlying observation (via @geogristle) is that controlled languages built for human safety turn out to be exactly the constraint that stops models writing filler.

In the HN discussion, several people want it for their own emails and Slack messages, one shows an output that is still wordier than real STE, and another notes drily that this is the third ASD-STE100 submission in a fortnight: this week’s trend, though maybe a good one.

PostgreSQL internals visualised as a working 3D city: watch queries move through the engine like traffic. An independent educational prototype, openly flagged as early and reviewed, with a correction template for anyone who spots an inaccuracy. A playful companion to the Postgres survival guide.

The HN discussion is mostly delight (“I don’t know what I am looking at but it is fabulous”) plus useful feedback that the guided tour is too busy and should be interactive, and the tantalising idea of generating visualisations like this for whatever you’re currently learning.

Alexander Belanger of Hatchet distils Postgres operations into tiers: schema design, indexing and short transactions first; then understanding the query planner (EXPLAIN ANALYZE, accepting that seq scans sometimes make sense) and tuning autovacuum before bloat accumulates; then the sharp tools like FOR UPDATE SKIP LOCKED queues, partitioning, and trigger-based migrations. The framing that sticks: “queries either seq scan or they don’t”, so optimisation is more binary than it feels.

The HN discussion mostly adds what the guide leaves out: monitoring and alerting for the few fatal failure modes, and a backup and restore plan, which several commenters reckoned is the real first item on any survival guide.

A design tool from a former Figma engineer that uses diffusion models as the design engine for agents: generate and iterate on UI designs, turn them into working products, and build reusable brand systems. Interesting as a bet that agents need a visual design medium of their own rather than driving human design tools.

On your own machine an agent leaves two bad options: approve every command and babysit the prompt, or --dangerously-skip-permissions and hope nothing is one rm -rf from disaster. Clawk is the third option: cd into a repo, type clawk, and Claude Code (or Codex, or a shell) works inside a disposable Linux VM with your code mounted. The agent gets full autonomy inside walls, instead of limited autonomy on your laptop.

The HN discussion asks the obvious question (why not just Docker: answer, kernel isolation), jokes about agents escaping container jail, and reveals a crowded field: Fly Sprites, virtdev, take-ai-control. Agent sandboxing is having a moment.

An AI code review platform built around stacked PRs: break large changes into small sequenced ones, have AI review each, and merge through a stack-aware queue. Used by Shopify, Ramp and Asana. Bookmarked as the strongest productised bet that code review stays central in the agent era; the opposite wager to Gergely Orosz’s observation that reviews are fading.

Sam Rose hand-ported the core of Kubernetes to TypeScript so it runs entirely in the browser: pod lifecycle, cluster networking, DNS and deployment controllers, about 100,000 lines written with LLM assistance, every line reviewed, and 2,000-plus tests checked against a real k3s cluster. It ships at roughly 140KB gzipped and exists to power interactive Kubernetes tutorials. A nice data point for what one developer educator can now build with agents.

The HN discussion found the workflow more interesting than the artifact: the review discipline and testing against a real cluster is what separates it from vibe slop, with one commenter suggesting we’re on the cusp of only needing to read the tests. That, and the inevitable jokes about Kubernetes complexity.

A free handbook of the unglamorous fundamentals of building financial software: representing money (precision, rounding, currency, FX), double-entry ledgers, value time versus booking time versus settlement time, immutability and audit trails (and how that squares with GDPR), idempotency and full resumability of money flows, reconciliation, and controls like four-eyes and segregation of duties. Appendices walk end-to-end flows such as a crypto withdrawal. The kind of domain knowledge that usually lives only in the heads of people who’ve been burned.

In the HN discussion, a fintech veteran vouches that it matches five years of hard lessons (answering the now-obligatory “is this AI slop?” question), and the sharpest thread warns against using minor-units integer amounts as an interchange format, however clever it feels.

Anthropic’s collection of runnable guides for building with Claude: tool use, RAG, structured extraction, multi-agent orchestration, extended thinking, prompt caching, batching, and deployment patterns. Worth remembering as the first place to look for a working example of an API feature before writing one from scratch.

Satya Nadella used the term “cognitive coverage” on Hard Fork to describe how much of the code a developer understands when they commit it. Basically the flip side of cognitive debt, with a nice parallel to test coverage.

Addy Osmani separates cognitive offloading (delegating while keeping your own judgment) from cognitive surrender (accepting AI output without forming an understanding of your own). Engineers are unusually exposed: code looks correct by default, and productivity metrics can’t tell understanding from approval. The habit compounds into what he calls comprehension debt. His countermeasures are small and practical: form an expectation before reading the output, read diffs critically, ask the model for counter-arguments, and notice when fatigue is making you rubber-stamp.

Another name in the growing vocabulary around cognitive debt and cognitive coverage.

Annie Vella on a Thoughtworks retreat about the future of AI-driven software development. People are starting to name the questions around cognitive load, trust, platform foundations, agent governance, and the changing shape of engineering work. The key lesson for her was “Nobody has this figured out”

Simon Willison points to Margaret-Anne Storey’s useful framing of cognitive debt: the loss of shared understanding when AI helps teams move faster than they can explain. The code may work, but the team can still lose the plot.

Dan Shapiro’s scale for AI coding automation: level 1 offloads small tasks, level 2 pairs with an AI-native coding tool, level 3 manages agents through diffs, level 4 delegates from specs and plans, and level 5 is the dark factory where specs go in and software comes out.