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

Astra and Opus 5.5 make me think AI acceptance in games is close: stronger tools are giving people with visual taste a shorter path to something worth playing.

Read the essay
A hand adjusts a brass spotlight over a miniature lighthouse and sailboat, with a second lamp and a small paint box nearby.
Illustration generated with GPT Image

Pages from the notebook

105 of 131 essays

105 essays found. Page 1 of 9.

  1. The game has to look worth playing

    Astra and Opus 5.5 make me think AI acceptance in games is close: stronger tools are giving people with visual taste a shorter path to something worth playing.

  2. Make the code a little uwu

    AI reviewers can find real bugs and still need a better second question. Build the adversarial pass into the skill, then leave some room for cute, slightly embarrassing taste.

  3. Betting on lists

    Blot's lists put adding, removing, and iterating first. Dense leaves and shared tree branches make that a different bet from a contiguous array.

  4. Let me stay in the loop

    Creative AI tools need to make a small change visible while the idea is still fresh. Long autonomous runs solve a different part of the job.

  5. Let typeclasses keep the trace

    A CRUD example in typeclasses adds database tracing around typed operations, keeps the request program intact, and turns the resulting trace into an ordinary test value.

  6. A million lines is a budget

    Jonathan Blow's compile-speed target leaves only a few places to find the time: reduce the work, make it cheaper, or overlap it. The serial parts still get a vote.

  7. Jai puts the build in the program

    Jonathan Blow's language lets ordinary program code participate in compilation. The interesting part is what a project can ask its own compiler.

  8. Lobster borrows the argument

    Lobster checks generic functions at their concrete calls, then uses the same context to work out ownership. A short function carries more information than its syntax suggests.

  9. Goose keeps the address

    Goose lets an array grow around stable references by giving storage a stricter shape. The interesting part is what that shape asks of the rest of the program.

  10. The delay belongs in the import

    Python 3.15's explicit lazy imports make deferred module loading visible at the line that moves work, side effects, and failures to first use.

  11. The type checker gets a second context

    Fibre keeps principal structural types in one small algebra and moves refinements, relationships, dependent results, and generic predicates into a separate local logic.

  12. A generic should know less

    Facet treats types as bundles of observable surfaces, then compiles a generic against the exact layout, operations, families, and facts it actually uses.

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.