Skip to content

Still Brook.

Observations & other curiosities

Notes on software
and the things
we make.

Open the notebook
An engraved computer on spindly legs beside a brook, with a bird, a leafy twig, and a curling paper tape.
Fig. 01 — A machine for wandering thoughts.

Latest essay

A couture show has two customers for each camera frame. The archive wants every stitch. The backstage monitor wants whatever just happened. Jai and Goose put a very different price on that handoff.

Read the essay
A model in a pleated red coat turns on top of a film camera.
Illustration generated with GPT Image

Pages from the notebook

107 of 133 essays

107 essays found. Page 9 of 9.

  1. The review needs a suspect

    An LLM can catch bugs in its own patch because the first draft gives the review pass concrete evidence to inspect.

  2. Typeclasses with the grain

    Functional programming in TypeScript becomes elegant when Haskell's laws are translated through native JavaScript shapes instead of copied as foreign syntax.

  3. The ternary hangover

    AI writes nested ternaries without feeling their weight, leaving the reviewer to reconstruct control flow from punctuation.

  4. Make evaluation visible

    Haskell performance improves when you measure demand, allocation, and residency, then make evaluation and representation explicit only at proven hot paths.

  5. Tokens for yesterday

    AI spends much of its intelligence preserving documents and workflows that only exist because human coordination used to be slow.

  6. Beyond recursion

    Recursion describes repeated structure well, but production traversal needs explicit work once depth, cycles, budgets, or cancellation matter.

  7. Comptime behind glass

    Zig's comptime is useful, but a public API generated where the editor can't see it makes the feature harder to trust.

  8. The building block economy

    Agents make integration cheap enough that small, dependable capabilities can become products in their own right.

  9. The functional inheritance

    Mainstream languages quietly inherited functional programming, and the next step is making mutation and effects visible in the types.

  10. The compiler on the wide machine

    A compiler can run on the GPU only if the language it compiles breaks the build into many small independent jobs.

  11. Building for the second reading

    A note on making software that grows clearer when people return to it.

A note in the margin

A little curiosity goes a long way.

Still Brook is an independent journal about software, systems, and the quiet decisions that shape what we make.