Series

Posts that build on each other, in reading order.

Agents on large codebases

What a coding agent needs to work on a codebase it can't read in one go: a map of the code, review that sees relationships rather than lines, an inner loop with real sensors, and MCP servers that earn their place.

  1. Building a Code Knowledge Graph for AI Agents
  2. A Code Knowledge Graph for Review, Not Generation
  3. Code Review After the Pull Request
  4. The Agentic Inner Loop: Sensors, Substrate, and Skills for Polyglot Development
  5. Making a Code Graph Admit What It Doesn't Know (symgraph)
  6. When an agent can already write the file, what is an MCP server for?

Architecture the agent can check

Compilers, tests and linters only know about the repository an agent is standing in. These posts are about making architecture — layering, dependencies, API contracts — something the edit loop can fail on.

  1. A Rust-Native Architecture Toolchain: forge, puml, and adoc
  2. Architecture the Agentic Loop Can Actually Check (tropism)
  3. Giving the Consumer a Representative in the Working Tree (brake)

Building your own tools

When software has exactly one known user, it can drop its whole configuration layer. What that changes, and what it costs to run a personal estate of tools: release pipelines, CI budgets, account automation and agent safety.

  1. A Control Plane for a Personal GitHub Account
  2. Building Your Own Tools
  3. Cadence is a budget line: what scheduled automation cost a private repo
  4. Letting an agent read your mail: split the reader from the network
  5. Stop declaring what you can already read (myspec)
  6. The release pipeline four tools kept reinventing (release-kit)

Event-driven architecture

Patterns for event-driven systems, from notification and stateful events through event sourcing and integration to measuring consistency. Written in 2017 and migrated from the Jekyll site, with the diagrams now rendered by puml.

  1. Notification Event Pattern
  2. Event-Carried State Transfer Pattern
  3. Event Sourcing
  4. Consistency
  5. Measuring Consistency
  6. Integrating Event Driven systems
  7. Compensating Actions