Planned reference runs

Runs 4 to 10 are written. Runs 11 to 14 are specified and not yet started, and the wider shelf after them is a list of candidates, not a commitment.

Runs 4 to 7 launched and finished on 8 October 2026: 98 posts, 196 agents, zero failures, 25.30M subagent tokens. The posts they own are listed in _data/run_manifest.yml; RUN-STATUS.md and python3 scripts/run-status.py carry the state, recomputed from the posts in git rather than from this file. What stays useful here is the reasoning: why each run contains what it contains, and the rules every run inherits.

Two things changed between the plan and the launch. Run 8’s four hexagonal posts went into run 6 rather than running separately, since four posts do not justify a workflow and they belong in the same group. And the Elections block picked up How Does a Vote Get Counted?, which was sitting unpublished in the Numbers group and is the natural first post of the new one, making that group four posts rather than three.

The three October 2026 runs put 81 posts into 2030-09-19 to 2032-04-22, so the first slot here is 2032-04-29 and the last is 2034-03-23.

Scheduling consequence, stated once

The Thursday queue carries one post a week, shared between Under the Hood, Consulting and Craft, The Workshop and High Performance Teams. The 81 posts in flight plus the 98 below are 179 posts, which at one a week runs the Thursday queue from 2030-09-19 to 2034-03-23.

That is the arithmetic, not an objection. Two ways to shorten it if the runway becomes a problem, both of which are a decision rather than a detail:

Neither is assumed here. Everything below is laid one a week.

Updated 9 October 2026, because the arithmetic moved. Runs 10 to 14 add 116 posts and take the Thursday queue to 2036-09-04. The wider shelf below them is a further 224, which at one a week ends in February 2041. That is the number that makes the second Thursday slot a real decision rather than a hypothetical: a post written now and published in 2041 is written for nobody. The recommendation is the 20:25 slot, since the mechanism already exists and exam days already use it, and it halves everything above. It stays a decision, and the dates below assume it has not been taken.

Run 4: the remaining Under the Hood suggestions (18 posts)

Four new groups, each verified absent from the corpus before being proposed. Group pages are created by hand before the run, never by the agents writing the posts.

Group Posts Slots
Air 4 2032-04-29 to 2032-05-20
The Archive 4 2032-05-27 to 2032-06-17
Trades 4 2032-06-24 to 2032-07-15
Assessment (second block) 3 2032-07-22 to 2032-08-05
Elections 3 2032-08-12 to 2032-08-26

Seven group pages were created by hand before the runs started: air, the-archive, trades, elections, data-structures, patterns and integration. Assessment already had one.

Air. How a weather balloon works and why the upper atmosphere is measured by throwing something away. What an air quality monitor actually measures and why the particulate fractions are defined by size. How a tropical cyclone is forecast, and how the naming and category systems work. How refrigeration moves heat the wrong way up a gradient.

The Archive. How a library decides where a book goes, and classification as a lossy projection of a multidimensional subject onto a shelf. What a records retention schedule is for, and why destroying records on time is a legal act rather than negligence. How a museum decides what to keep, and accession as an irreversible commitment. Digital preservation and format obsolescence, where the medium outlives the reader.

Trades. How a house is wired, and why the rules are the shape they are: the earth path, the protective device, and what an RCD detects that a fuse cannot. How plumbing stops sewer gas coming back up, which is the trap and the vent and nothing else. How a slab is poured, cured and reinforced, and what goes wrong underneath it. What a building inspection actually checks, and what it explicitly does not.

Assessment, second block. How a driving test is standardised across assessors. How a trade licence is assessed when the thing being assessed is a physical skill. How university marks are scaled and moderated, and why a raw mark is almost never the reported mark.

Elections, beyond counting. How Does a Vote Get Counted? already exists and covers preferential and Senate counting. Not covered: how an electoral roll is maintained and why enrolment is the hardest data problem in the exercise; how a boundary redistribution is actually run; how pre-poll, postal and declaration votes are reconciled against the roll without anybody voting twice.

Run 5: Data Structures, in Go (22 posts)

New Under the Hood group, Data Structures, at /writing/data-structures/.

Every post answers the same six questions, in this order, which is the commission: what the structure is, what it costs (time and space, and the constant factors Go actually imposes), when to reach for it, when not to and what to use instead, how to implement it in Go, and how to test it. The testing section is the one that usually gets skipped and is the reason to write the series: a property-based test over a reference implementation finds more than any number of hand-written cases.

These are not -in-go tail posts. That suffix is reserved for posts pegged to a parent that publish the day after it in the 20:25 slot; these are standalone and take ordinary Thursday slots.

Go-specific content is the point of difference. Slices are not arrays, append aliasing is the most common real bug, map iteration order is deliberately randomised, container/list and container/heap exist and are mostly the wrong choice, generics changed what is writable, and escape analysis decides whether a node allocation is free.

  1. Arrays and slices, and what append actually does
  2. The dynamic array, and why amortised growth is not a trick
  3. The singly linked list, and when a pointer chase is worth it
  4. The doubly linked list, and why container/list disappoints
  5. The stack
  6. The queue
  7. The ring buffer
  8. The deque
  9. The hash map, and how Go’s map actually works
  10. The set, and why Go makes you build it
  11. The binary search tree
  12. Self-balancing trees, and the cost of keeping a promise
  13. The B-tree, and why disks changed the shape
  14. The binary heap and the priority queue
  15. The trie
  16. Graphs: adjacency list against adjacency matrix
  17. Union-find, and the two tricks that make it almost free
  18. The Bloom filter, and being wrong on purpose
  19. The skip list, and probability instead of balancing
  20. The LRU cache, and composing two structures
  21. Fenwick and segment trees, for ranges
  22. Persistent structures, and sharing instead of copying

Run 6: Patterns, the Gang of Four (24 posts)

New Under the Hood group, Patterns, at /writing/patterns/.

Post 1 is an introduction and it is what makes this series worth writing: what a design pattern is, that the catalogue is a description of what C++ and Smalltalk programmers kept building in 1994 rather than a prescription, and the honest critique. Several GoF patterns are workarounds for the absence of a language feature. A first-class function dissolves Strategy and Command. Go’s implicit interfaces dissolve much of Adapter. Iterator is a range loop. The series says so in post 1 and then treats each pattern as a named solution to a real recurring problem, with the honest note on whether it is still earning its place.

Creational: Abstract Factory, Builder, Factory Method, Prototype, Singleton. Structural: Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy. Behavioural: Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, Visitor.

Each post: the problem it solves, the structure, a worked implementation, what it costs in indirection, when it is the wrong answer, and what a modern language gives you instead.

Run 7: Integration, the Enterprise Integration Patterns (30 posts)

New Under the Hood group, Integration, at /writing/integration/.

Hohpe and Woolf catalogue 65 patterns. Thirty are planned here: the integration-styles decision plus the patterns that recur in real systems. The remainder are mostly variants and narrow cases, and the run can be extended if the first thirty prove worth it.

Styles and channels (6). Choosing an integration style: file transfer, shared database, remote procedure invocation, messaging. Point-to-point channel. Publish-subscribe channel. Dead letter channel. Guaranteed delivery. Invalid message channel.

Message construction (4). Command, document and event messages, and why the distinction decides the coupling. Request-reply. Correlation identifier. Message expiration.

Routing (8). Content-based router. Message filter. Recipient list. Splitter. Aggregator. Resequencer. Scatter-gather. Process manager, and why a routing slip stops being enough.

Transformation (4). Message translator. Envelope wrapper. Content enricher and content filter. Claim check.

Endpoints (6). Polling against event-driven consumers. Competing consumers. Idempotent receiver, which is the one everybody needs and few build. Transactional client. Messaging gateway. Service activator.

Management (2). Wire tap. Control bus and the message store.

Run 8: Hexagonal architecture (4 posts, folded into run 6)

Lands in the Patterns group rather than its own, since four posts do not carry a group page, and was written as the tail of run 6 for the same reason.

  1. Ports and adapters, and what the hexagon is actually separating
  2. What goes inside the hexagon, which is the only hard question
  3. Testing at the boundary, and the test double that earns its place
  4. Hexagonal in Go, where implicit interfaces change the ergonomics

Run 9: Applied Patterns (10 posts)

Written. Launched and finished on 9 October 2026: 10 posts, 20 agents, zero failures, 2.80M subagent tokens across two workflows (1.34M and 1.47M), 41 and 52 minutes. That is 280,000 subagent tokens a post against runs 4 to 7’s 258,000, and the difference is the diagrams: five a post, drawn rather than described.

What the check pass caught, which is the argument for having one:

Four takeaways came back at 26 to 29 words against the 25-word cap and were shortened by hand after the check pass had passed them. Tighten that in the next brief: tell the check agent to count the words rather than judge the length.

The group page writing/applied-patterns/index.html was created by hand before the run, per rule 1. The canonical nine-heading structure is in CLAUDE.md under “The Applied Patterns group”.

Slots are the ten Thursdays after the last Integration post, 2034-03-30 to 2034-06-01, and the date is a constraint rather than a preference: a post here uses patterns from the Patterns, Integration and Data Structures groups, and the chronological rule forbids using a pattern before its own post publishes. Integration’s last post is 2034-03-23, so nothing in this group can sit earlier than the week after.

Every scenario is a different company, in a different industry, in a different city, and no two posts weigh the same set of patterns.

Slot Slug Problem Patterns weighed
2034-03-30 the-same-file-twice A Fremantle fruit importer’s nightly supplier stock file arrives twice because the supplier’s scheduler double-fires. Finance finds it three weeks later in a stocktake, by which time the reorder has already gone out. Idempotent Receiver, Correlation Identifier, Message Store, Claim Check, Dead Letter Channel
2034-04-06 when-the-downstream-is-down-for-a-day A Brisbane equipment-hire business takes bookings all day while the billing system it must notify is down for a planned 14-hour migration. Bookings cannot stop and invoices cannot be lost. Transactional Client, Guaranteed Delivery, Competing Consumers, Proxy
2034-04-13 twelve-suppliers-twelve-shapes A Hobart seafood co-op receives catch declarations from twelve boats in twelve formats, and one reporting warehouse has to hold all of them without a column per boat. Message Translator, Content Enricher, Content Filter, Envelope Wrapper, Adapter, Abstract Factory
2034-04-20 a-packhouse-with-no-network A Mildura citrus packhouse on a link that drops for twenty minutes at a time. The grading line cannot stop when the link does, and nothing it recorded may be lost. Guaranteed Delivery, Polling Consumer, Claim Check, Command, Ring Buffer
2034-04-27 a-price-that-explains-itself An Adelaide insurance broker’s quoting engine. A customer disputes a premium, and nobody can say which rules fired or in what order. Composite, Strategy, Interpreter, Visitor, Memento
2034-05-04 two-per-cent-and-reversible-in-a-minute A Melbourne transport-ticketing app rolling a new fare calculation out to two per cent of journeys, with a one-minute path back if the first hundred look wrong. Strategy, Proxy, Observer, Control Bus, Wire Tap
2034-05-11 an-api-on-a-ten-year-old-monolith A Perth building society’s core ledger has to expose an accounts API. The ledger is correct, in production, and nobody is rewriting it. Facade, Adapter, Messaging Gateway, Wire Tap, Service Activator
2034-05-18 an-approval-that-crosses-three-systems A Sydney council’s development application touches planning, building and health, each with its own system and its own idea of a decision. Any of the three can send it back. Process Manager, Command, Memento, State, Dead Letter Channel
2034-05-25 nine-million-readings-an-hour A Pilbara mine site’s conveyor monitoring. Nine million readings an hour, queryable live for the control room and kept for a year for the engineers. Flyweight, Ring Buffer, Aggregator, Resequencer, Claim Check
2034-06-01 an-audit-trail-somebody-has-to-prove A Canberra payroll bureau in a Fair Work dispute has to show who changed an award rate, when, and what it was before. Event Message, Message Store, Memento, Visitor, Guaranteed Delivery

Each post gets four to six diagrams, which is the main way this run differs in cost from runs 4 to 7: at least one for the context before, one for the assembly, and one for a mechanism inside Building it. The 36 diagrams added in October 2026 are the reference for the convention, and scripts/measure-diagram-text.py is the check that no diagram’s text runs off the right edge.

Two faults to brief against specifically, both of them ways a post of this shape fails while looking finished:

Runs 10 to 14: the catalogues behind the one-post overviews (116 posts)

Commissioned 9 October 2026. The pattern the first four runs found by accident is now the selection rule: the blog already carries a one-post overview, and the run is the catalogue depth behind it. Machines’ six hardware posts sat above Data Structures; Paradigms’ How Do Programs Do Many Things at Once? sits above Concurrency; When to Cache, When to Replicate, and When to Shard sits above Distributed Systems. Each of the five below was checked against the corpus before being proposed, by mentions and by title:

Run Group Posts Measured gap
10 Algorithms 28 quicksort 1 mention, Dijkstra 6, KMP/Boyer-Moore/Rabin-Karp 0, Huffman/LZ77 1. 0 titles.
11 Concurrency 26 goroutine in 44 posts and mutex/errgroup in 36, all incidental code. No post teaches the memory model or a named pattern.
12 Distributed Systems 30 Raft 3, Paxos 5, vector clock 2, consistent hashing 1, CRDT 2, saga 3. quorum 15, always assumed. 0 titles.
13 Refactorings 16 refactor appears 56 times as a verb and never as a named technique.
14 Resilience 16 circuit breaker 24, bulkhead 1, backpressure and load shedding 10. 0 titles. No overlap with The Service Manual, which is all AWS services.

Laid one a week from the first free Thursday after the Integration and Applied Patterns runs: Algorithms 2034-06-08 to 2034-12-14, Concurrency to 2035-06-21, Distributed Systems to 2036-01-24, Refactorings to 2036-05-15, Resilience to 2036-09-04.

Cost, so nobody plans a session around the wrong number. Measured over four full runs, a reference post costs about 258,000 subagent tokens, and about 280,000 where it carries five diagrams. 116 posts is therefore roughly 31M subagent tokens, which is more than a single session’s budget. These runs go one at a time, each in its own session, and this file is how the next session knows where the last one stopped. Run 10 is written; 11 to 14 are specified below and launch-ready.

Run 10: Algorithms (28 posts, 2034-06-08 to 2034-12-14)

The companion to Data Structures: that group covered what holds the data, and nothing in the corpus covers what runs over it. Every post backlinks into it, which is why this run goes first.

Structure is Data Structures’, verbatim, because it works: a post-specific first heading naming the mechanism, then ### Where the cost goes, ### The shape of problem it fits, ### When not to, and what instead, ### Writing it in Go, ### How to test it.

Foundations (3): what makes an algorithm fast; linear and binary search; recursion and the call stack. Sorting (5): the quadratic pair; merge sort; quicksort; heapsort and what Go actually sorts with; counting, radix and bucket. Selection (1): quickselect and the median. Graphs (7): BFS; DFS; topological sort; Dijkstra; Bellman-Ford; A*; minimum spanning trees. Dynamic programming (3): what it actually is; knapsack and coins; edit distance. Strings (3): Knuth-Morris-Pratt; Boyer-Moore and Rabin-Karp; suffix arrays and Aho-Corasick. Greedy (1). Randomised and approximate (3): reservoir sampling and shuffling; hashing as an algorithm; sketches. Compression and arithmetic (2): Huffman and Lempel-Ziv; fast exponentiation and Euclid.

Huffman is the canonical greedy proof and also its own post. The greedy post uses interval scheduling and fractional knapsack instead, and points at the compression post rather than doing it twice.

Runs 11 to 14, specified

Run 11, Concurrency (26). The memory model and happens-before first, because every later post depends on it, then the primitives (mutex and RWMutex, condition variables, semaphores, barriers and latches, atomics and CAS, channels, context cancellation), then the named patterns: worker pool, fan-in and fan-out, pipeline, Active Object, Monitor Object, Reactor, Half-Sync/Half-Async, Leader/Followers, thread-specific storage, single-flight, rate limiting, lock striping, copy-on-write, immutability, double-checked locking and why it is wrong. Closes on the failure catalogue: deadlock, livelock, priority inversion, false sharing, and the race detector. Diagram shape is new to the blog: goroutine timelines with happens-before edges drawn between them. Backlinks to How Do Programs Do Many Things at Once? and to Data Structures throughout.

Run 11 is laid out post by post below, because a topic pool is not a post list: the paragraph above names 28 things for 26 slots, and which ones merge is a decision worth recording rather than re-making. Half-Sync/Half-Async, Leader/Followers and thread-specific storage are the three dropped as their own posts; each is a section inside the Reactor or Worker Pool post instead, since none of them carries 3,000 words on its own in a language with goroutines. Slots run 2034-12-21 to 2035-06-21, every one a verified Thursday, skipping 24 Dec to 1 Jan, and no slug collides with anything on disk.

# Date Title Slug
1 2034-12-21 What Concurrency Actually Costs what-concurrency-actually-costs
2 2035-01-04 The Go Memory Model the-go-memory-model
3 2035-01-11 The Race Detector the-race-detector
4 2035-01-18 Atomics and Compare-and-Swap atomics-and-compare-and-swap
5 2035-01-25 The Mutex the-mutex
6 2035-02-01 The Read-Write Mutex the-read-write-mutex
7 2035-02-08 Condition Variables condition-variables
8 2035-02-15 Semaphores and Bounded Concurrency semaphores-and-bounded-concurrency
9 2035-02-22 WaitGroups, Barriers and Latches waitgroups-barriers-and-latches
10 2035-03-01 Channels channels
11 2035-03-08 Select, and Its Randomness select-and-its-randomness
12 2035-03-15 Context and Cancellation context-and-cancellation
13 2035-03-22 The Worker Pool the-worker-pool
14 2035-03-29 Fan-Out and Fan-In fan-out-and-fan-in
15 2035-04-05 The Pipeline the-pipeline
16 2035-04-12 The Active Object the-active-object
17 2035-04-19 The Monitor Object the-monitor-object
18 2035-04-26 The Reactor and the Event Loop the-reactor-and-the-event-loop
19 2035-05-03 Single-Flight and Request Coalescing single-flight-and-request-coalescing
20 2035-05-10 Rate Limiting and the Token Bucket rate-limiting-and-the-token-bucket
21 2035-05-17 Lock Striping and Sharded Counters lock-striping-and-sharded-counters
22 2035-05-24 Copy-on-Write and Immutable Snapshots copy-on-write-and-immutable-snapshots
23 2035-05-31 Deadlock deadlock
24 2035-06-07 Livelock, Starvation and Priority Inversion livelock-starvation-and-priority-inversion
25 2035-06-14 False Sharing and the Cache Line false-sharing-and-the-cache-line
26 2035-06-21 sync.Once and Double-Checked Locking sync-once-and-double-checked-locking

Shape of the run: four foundation posts (1 to 4) that every later one depends on, six primitives (5 to 10), cancellation (11 and 12), eight named patterns (13 to 20), two sharing strategies (21 and 22), then the four failure modes (23 to 26). The diagram shape is new to the blog, and is the reason this run is worth its own brief rather than the Algorithms one: goroutine timelines with happens-before edges drawn between them.

Run 12, Distributed Systems (30). Unmesh Joshi’s catalogue, in his dependency order: write-ahead log, segmented log, low-water mark, singular update queue, request waiting list, heartbeat, leader and followers, generation clock, high-water mark, quorum, Paxos, replicated log, Raft as the readable one, consistent core, lease, state watch, versioned value, version vector, Lamport clock, hybrid logical clock, clock-bound wait, gossip dissemination, emergent leader, fixed partitions, key-range partitions, two-phase commit, follower reads, consistent hashing, CRDTs, sagas. The risk is re-teaching Integration: Idempotent Receiver is already an EIP post and the saga overlaps the Process Manager, so both posts link back rather than restating, and the brief has to say so.

Run 13, Refactorings (16) and Run 14, Resilience (16) are laid out post by post below, in their own sections, because a topic pool is not a post list: run 11’s paragraph named 28 things for 26 slots and the merge decisions were worth recording rather than re-making.

Run 13: Refactorings (16 posts) – WRITTEN 11 October 2026

Fowler’s catalogue curated hard, because most of the 60-odd entries are too small to carry a post. The pairing with Patterns is the frame: Patterns says what to build, this says how to get there from what is already there.

Probed 11 October 2026. Every entry below is at zero titles, and all but two at fewer than eight mentions. refactoring itself: 16 mentions, no post.

One change against the original spec. It named the strangler fig as the system-scale entry, and the strangler fig already has three titles: Technical Migration: The Strangler Fig in Go (What Growth Takes, narrative, and it is in Go) plus two Exam Room posts. That slot becomes Branch by Abstraction (1 mention, 0 titles), which does the same job at the same scale and is untaught.

Shape. The six-heading catalogue structure, as runs 10 to 12 used: ### Where the cost goes, ### The shape of problem it fits, ### When not to, and what instead, ### Writing it in Go, ### How to test it, after an opening h3 named for the refactoring. Go throughout, two or three diagrams. The diagram shape is new and is the run’s distinguishing feature: before and after, with the mechanical steps between them numbered, because a refactoring is a sequence of safe states and a single picture of the endpoint hides the part that matters.

# Title Slug The prompt
1 What Refactoring Actually Is what-refactoring-actually-is Opens the run. Behaviour-preserving change, and the test suite as the thing that makes it possible rather than a chore beside it. The two-hat rule. Why “refactor” as a synonym for “rewrite” has made the word useless in planning conversations. Not about any one refactoring; it sets the vocabulary the other fifteen use. Run 10’s opener came back as a second binary-search post, so say in the brief what it is not.
2 Extract Function extract-function The one everybody does and few do well. Naming the extracted thing after what it means rather than what it does; the parameter list as the measure of whether the seam is in the right place; when extracting makes the caller harder to read.
3 Inline Function inline-function The inverse, and the one nobody reaches for. An indirection that earns nothing. The sequence matters: inline first to see the whole, then re-extract along a better seam.
4 Extract Class extract-class When a struct has two reasons to change. The field-clustering test. What moves with the fields and what stays. Links to the Patterns run’s single-responsibility material rather than restating it.
5 Move Function and Move Field move-function-and-move-field Where behaviour belongs, decided by what it touches. The Go-specific wrinkle: a method’s receiver is the declaration of where it lives, and moving one across a package boundary is an API change.
6 Introduce Parameter Object introduce-parameter-object Four arguments that always travel together. The option-struct idiom in Go, and the moment a parameter object turns into a domain type.
7 Replace Primitive With Object replace-primitive-with-object A string that is really an email address. Go’s named types, why type UserID string is weaker than it looks, and the validation that has to live at the boundary.
8 Replace Conditional With Polymorphism replace-conditional-with-polymorphism The switch that appears in four places. Interfaces in Go, and the honest counter-case: one switch in one place is clearer than four implementations of an interface.
9 Decompose Conditional decompose-conditional A boolean expression nobody can read aloud. Naming the clauses. Where this and guard clauses disagree.
10 Replace Nested Conditional With Guard Clauses replace-nested-conditional-with-guard-clauses Go’s dominant idiom and the reason if err != nil { return } reads the way it does. Happy path at the left margin. The nesting depth at which a function is the problem rather than its conditionals.
11 Split Phase split-phase Parsing separated from acting. Why this is the refactoring that most often precedes a test becoming possible. The two-pass shape and what it costs in allocation.
12 Split Loop and Replace Loop With Pipeline split-loop-and-replace-loop-with-pipeline Two refactorings in one post because they are the same argument about a loop doing two jobs. Go 1.23 range-over-func and iter.Seq, measured: what the pipeline costs against the hand-rolled loop. Links to Concurrency’s pipeline post, which is a different thing with the same name.
13 Encapsulate Collection encapsulate-collection Returning a slice is handing out a mutable interior. Copy, iterator, or read-only view, measured. The Go-specific trap: a nil slice, an empty slice, and a caller that appends to what you returned.
14 Separate Query From Modifier separate-query-from-modifier A function that answers and changes. Why it defeats caching, retry and tests. Where Go’s multi-return makes the violation tempting.
15 Replace Constructor With Factory Function replace-constructor-with-factory-function Go has no constructors, which makes this a post about New conventions, zero values that work, and the validation a factory can enforce that a struct literal cannot.
16 Branch by Abstraction branch-by-abstraction The system-scale one, replacing the strangler fig because that is already taught in Go. An abstraction over the old implementation, a second implementation behind it, and the traffic moved a slice at a time. Links to the three existing strangler-fig posts rather than competing with them.

Run 14: Resilience (16 posts) – WRITTEN 11 October 2026, 2031-02-26 to 2031-06-11

Nygard’s stability patterns and antipatterns. Every one is named in Exam Room prose and taught nowhere, which is the gap: the exam posts say “put a circuit breaker here” and no post says what one is.

Probed 11 October 2026. Zero titles across all sixteen. The mention counts say how often the blog leans on a thing it never explains: timeout 229, jitter 42, circuit breaker 27, steady state 27, backpressure 13, retry storm 9, fail fast 8. Five are at zero mentions as well as zero titles: hedged requests, handshaking, the blocked-thread cascade, decoupling middleware, dark launch.

Shape. The same six-heading structure, in Go. The diagram shape is the failure sequence: a message flow that works, then the same flow under the failure, with the moment of collapse marked. At least one diagram per post shows the thing going wrong rather than the thing working, because the pattern only makes sense against the failure it prevents.

Order matters here more than in run 13. The first four are the primitives every later post composes, and the last three are the failure modes the whole run exists to prevent, so they land once the reader has the vocabulary.

# Title Slug The prompt
1 What Resilience Actually Costs what-resilience-actually-costs Opens the run. Every pattern here trades capacity, latency or correctness for survival, and a system with all sixteen is slower and more complex than one with none. The question each post has to answer: what does this one give up. Not about any one pattern.
2 The Timeout the-timeout 229 mentions, no post. Where the number comes from, why a timeout longer than the caller’s is useless, and the deadline that propagates. Go’s context.WithTimeout and the connection-pool interaction that makes a timeout fail to fire.
3 Retry, Jitter and the Retry Storm retry-jitter-and-the-retry-storm Retry as the thing that turns a blip into an outage. Exponential backoff, full against decorrelated jitter, measured on a simulated fleet. The retry budget, and why retrying a non-idempotent call is a correctness bug rather than a reliability one.
4 Fail Fast fail-fast Checking before starting. The cost of discovering at second 29 of a 30-second timeout what you could have known at millisecond zero.
5 The Circuit Breaker the-circuit-breaker 27 mentions, no post, and the one the Exam Room leans on hardest. Three states, the two thresholds, the half-open probe. The failure mode nobody writes about: a breaker that never closes because the probe is the one request that always fails.
6 The Bulkhead the-bulkhead Partitioned resource pools, so one slow dependency cannot take every worker. Measured: one pool against four, with one dependency at 10 seconds.
7 Backpressure backpressure Telling the sender to slow down, and the three places to put it. Why a queue without backpressure is a latency bomb with a buffer in front of it. Links to Concurrency’s channel material.
8 Shedding Load shedding-load Refusing work to keep serving the rest. Choosing what to drop, and why dropping the cheapest request is usually wrong. Admission control against a priority queue, measured under overload.
9 The Governor the-governor Rate-limiting your own side, so an automated process cannot do unbounded damage quickly. The autoscaler that scaled to 400 instances.
10 Hedged Requests hedged-requests Zero mentions. Sending a second copy after the p95 and taking the first answer. The tail-latency arithmetic, and the capacity it spends to get it.
11 Graceful Degradation graceful-degradation Serving something worse rather than nothing. Deciding in advance which features are shed and in what order, because deciding during the incident means not deciding.
12 Steady State steady-state 27 mentions. Anything that accumulates will eventually fill: logs, caches, sessions, temp files. Purge with the data rather than with a cron somebody will delete.
13 Handshaking handshaking Zero mentions. Asking whether the other side can take the work before sending it. Why health checks are a degenerate handshake, and what a real one costs.
14 The Test Harness the-test-harness Nygard’s, not a unit-test framework: a deliberately hostile counterpart that refuses connections, accepts and never answers, and sends a valid response one byte at a time. The failures integration tests never produce.
15 The Integration Point the-integration-point The antipattern the first fourteen posts defend against. Every out-of-process call as a crack, and the catalogue of ways one fails: refused, accepted-and-silent, slow, wrong, and the TCP-level ones that look like none of these.
16 The Blocked-Thread Cascade the-blocked-thread-cascade Zero mentions, and the run’s closer. How one slow dependency becomes a dead service: pool exhaustion, the goroutine that never returns, and why Go’s cheap goroutines move the symptom rather than removing it. The post that ties the sixteen together.

Slots for runs 13 and 14

Laid 11 October 2026, when run 13 launched. Run 12 ends 2030-10-02, so run 13 takes the sixteen Wednesdays from 2030-10-16 to 2031-02-12 after the blank one, skipping 2030-12-25 and 2031-01-01 for the Christmas blackout. Run 14 follows with a blank week at the boundary, 2031-02-26 to 2031-06-11. Both sets were checked disjoint against the posts on disk, by date and by slug, and every link target the run can reach is dated 2030-10-02 or earlier, so all 165 are backward.

These are a starting lay, not a decision: reschedule.py --week agreed owns the catalogue stream and will move them with everything else.

The harness entry is Refactorings in scripts/workflows/write-reference-run.js, which gained three run-specific fields for it: diagrams (the before-and-after shape), references, and targets for the four catalogues that published between Algorithms and this run. Run 12’s brief named those four in prose and listed none of their slugs.

The wider shelf: catalogues checked and absent (224 posts)

Checked the same way, by mentions and by title. None of these has a single post titled for it. They are listed so the choice is a choice rather than whatever got thought of next, and in rough order of how well each fits the blog’s existing depth.

Candidate Posts Sits beneath Note
Database internals 18 Ledgers; How DynamoDB Actually Works B-tree against LSM, WAL, buffer pool, page layout, MVCC, isolation levels, 2PL, planner, join algorithms, compaction. 6 mentions total.
Test patterns 18 testing-at-the-boundary Meszaros’ catalogue: the five test doubles, fixture strategies, state against behaviour verification, builders, property-based, golden, contract, mutation.
Observability 16 The Service Manual Metric types, cardinality, why averages lie, exemplars, span propagation, head and tail sampling, SLIs and error budgets, the four profile kinds, eBPF.
Compiler construction 16 How Parsing Works, Compilers, Interpreters, and the Space Between Lexing, recursive descent, Pratt, LR, AST, type checking, IR, SSA, dataflow, register allocation, instruction selection, peephole, inlining, linking. 1 mention.
OS internals 16 Machines’ six overviews Scheduling algorithms, page tables, copy-on-write, syscalls, interrupts, io_uring, cgroups and namespaces, journaling and extent filesystems.
Network transport 16 Signals; How VPCs Actually Work Congestion control from Reno to BBR, Nagle, the TLS handshake, QUIC, HTTP/1.1 against 2 against 3, DNS resolution, NAT, anycast, load-balancer algorithms.
Caching 14 When to Cache, When to Replicate, and When to Shard Cache-aside through refresh-ahead, eviction policies beyond LRU, TTL jitter, the stampede, negative caching, CDN layering. 12 mentions.
Search and ranking 14 How Full-Text Search Works; The AI Field Guide Inverted index, tf-idf, BM25, vector search, HNSW and IVF, hybrid retrieval, re-ranking, query expansion, learning to rank.
Wire formats 14 Integration’s Envelope Wrapper JSON, CBOR, MessagePack, protobuf, Avro, Thrift, FlatBuffers, Parquet, Arrow, varints and zigzag, schema evolution, framing. Named in 44 posts, explained in none.
API design 14 Integration Resource modelling, idempotency keys, cursor against offset pagination, versioning, partial responses, bulk operations, long-running operations, error shapes, rate-limit headers.
Garbage collection 12 How Memory Actually Works, Why Caches Exist Reference counting, mark-sweep, mark-compact, copying, generational, write barriers, concurrent and incremental, arenas, escape analysis, slab and buddy allocators. 2 mentions.
Streaming 12 Integration Tumbling, sliding and session windows, watermarks, exactly-once, state stores, changelogs, stream joins, backfill. 35 mentions, 0 titles.
Build and packaging 12 - Incremental builds, content-addressed caching, hermeticity, SAT and pubgrub dependency resolution, semver, lockfiles, reproducible builds.
Auctions and markets 12 Money First and second price, Vickrey, English and Dutch, combinatorial, matching markets, deferred acceptance, revenue equivalence. The one non-software candidate, and the one most often explained badly elsewhere.
Version control internals 10 How Diff Works Content-addressed objects, the commit DAG, three-way merge, rebase against merge, bisect, packfiles, the reflog. 3 mentions.
Queueing and capacity 10 - Little’s Law, utilisation against latency, M/M/1, coordinated omission, the universal scalability law, load-test design. 8 mentions.

The theory streams, measured 9 October 2026 (90 posts)

Five streams, after the two decisions taken on 9 October: both information streams go ahead, distinguished by where they already live in the corpus, and the mathematics stream exists only to explain concepts the blog has already explored.

Probed by mentions and by title before any of it was proposed, and the result is the emptiest reading anything has given: zero titles across all twenty-six probes. Combinatorics, generating functions, recurrence relations, the master theorem, rate-distortion and source coding are at zero mentions. MDP, POMDP, value iteration, NP-complete, P vs NP, Kolmogorov complexity, the master theorem, planar graphs, modular arithmetic and the pigeonhole principle are at one each. Minimax, DFA, NFA, Turing machines, decidability, Hamming codes and Reed-Solomon are at two or three.

Group names below are proposals, not decisions. They follow the house register, which is short nouns (Time, Trust, Money, Signals, Ledgers, Paradigms, Games, Numbers, Law, Water, Air), and they deliberately avoid “Foundations” three times over.

The two information streams, and how the blog tells them apart

The distinguishing device turned out to be already built, which is better than inventing one. They are not two names for one subject; they are two places that already exist in the corpus.

Information science extends The Archive, which is already that group. Its four posts are How Does a Library Decide Where a Book Goes?, What Is a Records Retention Schedule For?, How Does a Museum Decide What to Keep? and What Happens When the File Format Dies?. That is knowledge organisation, appraisal, retention and format obsolescence, written as overviews. The run is the depth behind them, ~12 posts: faceted classification against enumerative, controlled vocabularies and why a free-text tag field decays, authority control and the same-name problem, metadata standards from Dublin Core to schema.org, FRBR and LRM and the work-expression-manifestation-item distinction, ontologies with RDF and OWL, provenance and chain of custody, archival appraisal as a decision procedure, retention schedules as policy made executable, citation and bibliometrics with the h-index’s own pathologies, and retrieval evaluation with precision, recall and nDCG. Practitioners meet this entire discipline as “why is our data catalogue useless”, which is the angle every post takes.

Information theory is a new group, proposed name Information. It sits beneath Signals (radio, MP3, video down the wire), beneath Numbers’ The Compression of Randomness, and beneath the ungrouped How Compression Works and How Randomness Works. ~14 posts: entropy and what it measures, the source coding theorem, Kraft’s inequality, Huffman’s optimality and where arithmetic coding beats it, mutual information, channel capacity, the noisy-channel coding theorem, parity and Hamming codes, Reed-Solomon, LDPC and turbo codes, erasure coding as object storage actually uses it, rate-distortion and why lossy is a different problem, cross-entropy and perplexity as the bridge to language models, and entropy sources for randomness.

The one-line distinction for a reader: Information is about the message, how much is in it and what survives a channel. The Archive is about the collection, how it is organised and what makes it findable years later. One measures, the other arranges.

Groundwork: the mathematics under what we have already explored (~16)

Reframed on 9 October, and the reframing fixes the two problems the stream had. A post exists here only if it explains the foundation of something the blog has already published, and it names that post. No anchor, no post: generating functions were in the first draft of this list and come out on exactly that rule, having nothing on the blog to explain.

This also dissolves the ordering trap recorded below. A stream that explains already-published posts links backward, so it can be laid anywhere in the queue. It was only a problem while the mathematics was meant to hold up future runs.

Topic What on the blog it is the foundation of
Induction and the loop invariant union-find’s two tricks, binary search’s invariant
Amortised analysis the dynamic array, the LRU cache (amortised appears in 31 posts, explained in none)
Recurrence relations and the master theorem merge sort, quicksort, self-balancing trees
Counting and combinatorics How Randomness Works, reservoir sampling
Inclusion-exclusion and cardinality estimation sketches, the Bloom filter
Probability, expectation and variance How Statistics Lie, Why Numbers Have a Shape
Tail bounds and concentration the p99 (percentile or p99 appears in 79 posts), Queueing Theory
Large numbers and the central limit theorem Sampling and Polling, How to Run an A/B Test Honestly
Bayes’ rule as arithmetic Bayesian Reasoning, Probability Paradoxes
Markov chains Queueing Theory, How Is a Forecast Made?
Modular arithmetic and number theory How Encryption Works, fast exponentiation
Finite fields Reed-Solomon and erasure coding in Information
Groups, and elliptic curves as one How Certificates Work, How Encryption Works
Graph theory as theory adjacency list or matrix, minimum spanning trees, How the Internet Routes Traffic
Sets, relations and relational algebra How Databases Actually Work (relational algebra appears in exactly one post)
Boolean algebra, lattices and fixpoints How CPUs Actually Execute, and dataflow analysis if the compiler run happens

The craft risk stands and the anchor rule is what manages it. This is the least blog-like thing proposed, the house style forbids the textbook register, and a post here that opens on a definition has failed. Each one opens on the thing it explains: the p99 post opens on a latency chart that lies, not on Chebyshev.

Reasoning: foundations of AI (~28)

The strongest of the five, because its overview layer already exists. The AI Field Guide is one post per AIMA chapter cluster: Search and Planning covers what Russell and Norvig spend four chapters on, Knowledge, Logic, and Constraints covers five, Bayesian Reasoning covers four, and How Reinforcement Learning Works, Causal Inference, Evolutionary Computation, Neurosymbolic AI, Knowledge Graphs and Trees, Forests, and Boosting each stand above a cluster of their own. Twenty-two backlinks waiting.

Agents and rationality (2). Adversarial search: minimax, alpha-beta, expectimax, Monte Carlo tree search (3). Constraint satisfaction: backtracking, arc consistency, the heuristics that make it tractable (2). Logic: propositional, SAT solving through DPLL and CDCL, first-order, resolution, forward and backward chaining (5). Planning: STRIPS and PDDL, partial-order, HTN, planning as satisfiability (3). Uncertainty: Bayes nets, exact and approximate inference, hidden Markov models, Kalman and particle filters (5). Decisions: utility, decision networks, MDPs, value and policy iteration, POMDPs (4). Learning theory: PAC, VC dimension, bias and variance (3). Reinforcement learning in depth (1).

SAT solving is the sleeper. Practitioners meet it as dependency resolution, which wires this run to the build-and-packaging candidate above.

Limits: foundations of computer science (~20)

What can be computed, and how fast. Automata and the Chomsky hierarchy, the DFA-NFA-regex equivalence and catastrophic backtracking, the pumping lemma, pushdown automata and context-free grammars, Turing machines, Church-Turing, the halting problem, reductions, Rice’s theorem, P and NP, Cook-Levin, NP-completeness as it is met in practice, approximation and hardness of approximation, space complexity, randomised classes, Kolmogorov complexity, lambda calculus, and Curry-Howard.

The most academic of the five and the one whose posts have to work hardest to be about something. The regex post is the proof it can be done, since “why is this pattern slow” is a question practitioners actually have, and Rules, Grammars, and Regex in the AI Field Guide plus How Parsing Works in Language are the overviews above it.

The constraint that still applies

Run 10 takes some of this ground first, so these briefs link rather than repeat. Algorithms covers A*, Dijkstra, BFS and DFS, which is AIMA’s informed-search material, so Reasoning starts at adversarial search. It covers Huffman and Lempel-Ziv reaching the entropy bound, so Information opens on a backlink to it rather than rederiving it. It covers fast exponentiation with Euclid, so Groundwork’s modular arithmetic post does the same.

The support-ordering trap that applied to the first draft of the mathematics stream no longer does, since Groundwork now links backward by construction. It would return the moment any of these streams is written to hold up a future run, so it is worth remembering: CLAUDE.md forbids a post using terminology before the post that introduces it, which means support content has to be laid ahead of what it supports, and that is the one failure here that cannot be fixed by editing a post afterwards.

Run 15: the organisational craft (33 proposed, 13 agreed)

Craig’s ask, across three conversations on 11 October 2026: the Six Thinking Hats and Minto’s writing frameworks, then decision recording and team health, then team documentation and ways of working, then project scoping and getting a backlog out of a vague one-pager. One subject underneath all four: the written and facilitated craft of working in an organisation.

13 posts were agreed, and the list below is 33. The growth is the three later asks, not scope creep from the first one. Craig sets the number; the split and the ordering below are the recommendation.

Why this run, and why The Workshop first

The corpus is empty here, measured 11 October by mentions and by title:

Probe Mentions Titles
Six Thinking Hats, de Bono, lateral thinking 0 0
Minto, Pyramid Principle, SCQA, MECE 1 0
Issue trees, logic trees, hypothesis-driven 0 0
Toulmin, steel man, Socratic, nemawashi, Chatham House 0 0
MADR, Nygard, Y-statement, arc42 5 0
RFC, design doc, decision log 98 0
Team health check, squad health, SPACE, maturity model 3 0
Ways of working, team charter, team API, definition of ready 6 0
WSJF, cost of delay, MoSCoW, Monte Carlo forecast, WIP limit 5 0

Two readings need care. INVEST at 274 mentions and spike at 108 are mostly “investigate” and GuardDuty; health check at 119 is entirely AWS load balancers, including its one title. Neither is coverage.

The Workshop is the queue that needs this. queue-runway.py --series on 11 October: Under the Hood 2286 days, Consulting and Craft 2146, High Performance Teams 1754, The Workshop 325. It runs dry on 2027-09-01, and it is the only Thursday series under two years. Fifteen Workshop posts take it to roughly 430 days, which is a dent and not a fix: The Workshop wants a restocking run of its own after this one.

What already exists, and what that means for the briefs

Four things to link to rather than repeat:

The Workshop (15): things you facilitate in a room

Each follows the canonical nine-h3 structure in CLAUDE.md.

# Title Note
1 The Workshop: Six Thinking Hats de Bono. Sits beside Cynefin and Decision Tables.
2 The Workshop: Lateral Thinking The provocation tools: PO, random entry, challenge. A different session from the Hats.
3 The Workshop: Issue Trees Hypothesis-driven structuring. Where MECE earns its keep.
4 The Workshop: Working Backwards Amazon’s PR/FAQ. Follows Impact Mapping and Jobs to be Done.
5 The Workshop: The Silent Pre-Read The six-pager meeting. A facilitation format, not a writing one.
6 The Workshop: Red Teaming a Decision Distinct from Pre-Mortem: challenges the reasoning, not the outcome.
7 The Workshop: Nemawashi Consensus laid before the meeting rather than in it.
8 The Workshop: Team Health Check The squad-health format, and how it becomes a management dashboard. The failure mode is the post.
9 The Workshop: The Decision Brief RAPID and DACI roles, the pre-read, what the meeting is for.
10 The Workshop: Chartering Ways of Working Working agreements that survive contact with a deadline.
11 The Workshop: Definition of Done and Ready Two gates, and what each one stops.
12 The Workshop: Backlog Refinement Next to Story Splitting; this one is the session, not the technique.
13 The Workshop: Inception Craig’s specific ask: a vague one-pager into a populated backlog.
14 The Workshop: Estimation Without Numbers T-shirt sizing, planning poker, and when to stop estimating. Links to Forecasting Without Estimates.
15 The Workshop: The Flow Review WIP limits, cycle time, Little’s Law, and reading a cumulative flow diagram.

Consulting and Craft (18): things you write alone

# Title Note
1 The Pyramid Principle Minto. Answer first, then grouped support.
2 SCQA Situation, complication, question, answer. The opening of anything that has to land.
3 MECE And the test for a bad group, which is the half people skip.
4 Putting the Recommendation First BLUF, the inverted pyramid, and when it is wrong.
5 Claim, Grounds, Warrant Toulmin, for an argument somebody will contest.
6 The One-Pager 29 incidental mentions, no post.
7 ADR Formats Nygard against MADR against Y-statements against arc42. Which fields earn their place.
8 The Decision Log ADRs are for architecture; most decisions are not architectural.
9 The RFC 48 mentions, no post. The proposal with a comment period, and when it beats a meeting.
10 The Design Doc Distinct from an RFC: one author, one change, reviewed before building.
11 Writing a Decision You Disagree With Recording it faithfully having lost the argument.
12 The Team README The team API: what we own, how to ask, when we say no.
13 The Glossary 12 mentions. Links to Building a Ubiquitous Language.
14 Acceptance Criteria 12 mentions, no post. Where Example Mapping output lands.
15 The Scope Note What a statement of work has to pin down, and what it cannot.
16 Scoring a Backlog WSJF, cost of delay, MoSCoW, and what each one quietly assumes.
17 A Roadmap That Is Not a Promise Now/next/later. Links to the narrative’s sales-objection-log post.
18 Forecasting From Throughput Monte Carlo on cycle-time data. Zero mentions of Monte Carlo forecasting.

Ordering, if the whole 33 run

The Workshop set goes first, because that queue is the one at 325 days. Inside it, 1 to 7 are the thinking tools and 8 to 15 the delivery ones, and either half stands alone if Craig wants it smaller. The Consulting and Craft set is three clusters that each stand alone: 1 to 6 writing, 7 to 11 decision recording, 12 to 18 team and delivery documents.

If 13 is the number, the recommendation is Workshop 1, 8, 9, 13 and Consulting and Craft 1, 2, 3, 7, 8, 9, 12, 16, 18: one de Bono, the team health check, the decision brief, the inception, Minto’s three, the three decision-recording formats, the team README, backlog scoring and forecasting. That covers every one of the four asks and leaves the rest shelved.

Slots

Unassigned. The Thursday queue is mixed post by post between four series and reschedule.py --week agreed lays it, so slots come from the relay rather than being chosen here. Verify disjointness before launch, per the rules below.

Rules every run above inherits

From the three runs in flight, because they were learned the expensive way:

  1. One agent, one new file. No agent touches _data/series.yml, any writing/**/index.html, any script, CLAUDE.md, or another post. All group pages are created by hand before the run.
  2. Slots are verified disjoint before launch: no date overlap and no slug overlap against every other run and against what is on disk, and every slot confirmed a Thursday.
  3. The title comes from the slug. The three October 2026 runs were specified with a positional maker, (date, slug, title, teach, intro), and the topic description went into the title slot on every non-Workshop post. Runs 4 to 7 pass a named object with an explicit title, which is why _data/run_manifest.yml carries a titles-from-slug list naming only the three runs the repair applies to: run-status.py reads it and leaves the newer titles alone. Where the repair is needed, scripts/fix-run-titles.py is idempotent, because a check-pass agent that rewrites a file restores the bad title.
  4. Write then check, as a pipeline rather than two phases, so a post is checked as soon as it is drafted. The check pass is where the bullets-instead-of-paragraphs fault and the factual overreach get caught.

  5. Reading times are stamped once for the whole set at the end, with make reading-times, never per post. Tell the check-pass agents to leave an existing reading_time alone, which the three October 2026 runs did not: their brief said only that a post must not carry one, so a reviewer rewriting a post after the whole-set stamp stripped it, correctly by its own instructions. It recurred six times across run 2’s tail. Runs 4 to 7 carry the fixed wording, item 17 of the check brief. The repair, if it happens anyway, is python3 scripts/run-status.py --fix.

  6. Four workflows at once, not one. A workflow’s concurrency cap is min(16, nproc - 2), and this box reports nproc 4, so a single workflow runs two agents whatever the token budget is. 98 posts is 196 agents, which is about nine hours in one workflow and about three in four of them. Each workflow gets a disjoint slot range and the guard text in every prompt says three others are writing, so no agent touches a shared file.