Book I.
Writing: thirteen propositions, in order of proof.
Essays and field guides on engineering with AI, software architecture, distributed systems, and the semantics of natural language. Each carries a figure drawn from its own argument.
XIII of XIII shown
- XIII
Your Docs Are a Corpus Now To prove: Why a repository's twelve hundred markdown files now have three readers (people, a wiki and a retrieval index), and what happened when we adopted Google's Open Knowledge Format, turned our READMEs into a company wiki and pointed our own RAG product at our own codebase.A stack of 1,266 markdown files joined by three lines to its readers: people, the wiki and the retrieval index - XII
One Query Language, From Filter Chip to Chart To prove: How a small, typed query language can carry a platform from the filter chips on a list page to a pivoting analytics engine, given one filter tree, one field schema and one sort form, compiled by a fold into SQL, CQL or whatever comes next.One filter tree, an AND of a status clause with an OR of a date and a name clause, folds into a SQL WHERE clause, a CQL query with a residual predicate, and a bar chart - XI
Rethinking Agile in the Age of AI To prove: Agile's values still hold, but its practices were tuned for a world where code was expensive. What six months of AI-driven development suggests about roles, design, review, estimation and the Definition of Done.Agent build time against time until done-done for epics, stories and tasks, on a log scale from one minute to one week - X
Six Months of Enterprise Development with AI To prove: What six months, 1,200 commits and 594 stories of building a production AI platform with agents taught me about what holds, what breaks, and where AI still falls down.Share of commits that fix or refactor: 51% without a theory, 32% with one - IX
The Top 50 Techniques for Distributed Engineering To prove: That nearly every distributed system is built from the same fifty techniques (sharding, quorums, idempotency, backpressure, circuit breakers and the rest), each shown here with a Go or Python implementation and, where it helps, a diagram.Seven replicas split by a network partition; the four-node majority can still commit - VIII
100 Patterns for Production Go and Python To prove: That a hundred design patterns, concurrency idioms, resilience strategies and architectural habits are what separate production Go and Python systems from prototypes, catalogued with an example for each.A ten-by-ten grid of one hundred cells filled in reading order across sixteen parts - VII
Professional Software Engineering for AI and Distributed Systems To prove: That the gap between writing code and engineering production systems can be taught, given a graduate course built on deliberate technical debt, an architecture defense and AI used as a force multiplier.A service graph with five sound edges and three broken red edges that students inherit, diagnose and defend - VI
Anatomy of an AI Engineering System To prove: How seventeen slash commands, seven templates and three model tiers, each of them short and single-purpose, turn Claude Code into a full software development lifecycle.Three concentric model tiers carrying seven template squares and seventeen command dots - V
The Ideal Repository Structure To prove: That strict layer boundaries, enforced by the directory structure itself, keep a codebase from decaying, with a detailed tour of interface-first, layered monorepo design in Go and Python.Nine stacked layers from entrypoints to core interfaces with dependencies pointing down only - IV
How I Learned to Love the Bomb To prove: Why I went from skeptic of AI-assisted programming to building an engineering system around it, and why what won me over was not the models but the discipline you wrap around them.A binary tree that doubles at each of five levels, from one skeptic to a chain reaction - III
The Decorator Pattern for Observability and Resilience To prove: Why logging, metrics, retry and circuit breaking belong in wrappers rather than in your business logic, with examples in Go and Python.A call enters through Recovery, Auth, Transaction and Observability rings, reaches the service, then unwinds - II
From Dependency Parses to Montague Semantics via Vector-Grounded Concept Bases To prove: That Universal Dependencies parses, a Montague-style typed lambda calculus and concept bases derived from vectors can be fitted together into a single compositional semantics pipeline, and how.Typed composition tree for the sentence “Every tall senator approved the new bill” with its logical form below - I
My Development Environment To prove: A tour of my macOS setup (zsh, Neovim, tmux and 80-odd command-line tools), all of it kept in one dotfiles repo that installs with a single command.A terminal window split into neovim, git and zsh panes, rebuilt by one install command