Notes on the
systems I build.

As AI products move from producing answers to carrying out work, the useful interface has to express outcomes, authority, evidence, and unfinished obligations. Chat is one surface over that contract.

Specialized reasoning does not require separate truths about permission, budgets, revisions, and task state. Those responsibilities need a common execution contract before delegation becomes dependable.

Natural language is a useful entry point. Exact titles, event identities, time arithmetic, permissions, and destination effects still need contracts that do not depend on conversational fluency.

A token cap does not bound an agent task. Steps, retries, delegated workers, tool costs, and uncertain provider usage need a shared account of what the system is allowed to consume.

A passing test can establish the wrong property when authentication, transport, scoring, or fixtures are broken. The evaluator needs its own contracts and positive controls.

A successful tool call establishes a bounded fact. Completing an agent task requires evidence for the outcomes the user requested, including the ones the last tool did not address.

Intelligence is rapidly becoming abundant. Trust is becoming scarce. The interesting products of the next ten years won't be about generating better output. They'll be about figuring out which output to rely on.

Trying to make the model better at admitting uncertainty is a losing game. Refusing in the orchestration layer. When the retrieval signal is too weak to support an answer. Is a winning one. Plus the companion move that matters at least as much.

Voluntary safety checks don't survive contact with a real agent. If you want a policy layer that actually stops destructive tools, it has to be in the request path. And once it is, you also get the team's shared context for free.

A tool schema describes the shape of a call. A dependable agent also needs prerequisites, effect scope, result meaning, and retry policy. Those contracts should drive both selection and dispatch.

A GCP build that pulls NYC's open crash, taxi, traffic, and weather feeds into a single analytical surface. Notes on why we picked Compute Engine + Dataproc over Composer + Dataflow, where the batching limits actually bit, and what would change in v2.

Permission checks at source-read time are insufficient when information survives in summaries, conversation history, and task journals. The restriction has to survive with the information.

Schemas, contracts, lineage, and policies carry the structure an LLM needs to be useful inside a regulated environment. The bytes don't. And shouldn't leave the perimeter.

Stopping token output, terminating a worker, and establishing the state of an external effect are different operations. An agent needs explicit rules for all three.

Treating agent memory as persistent infrastructure. With typed writes, provenance, retrieval policy, and decay. Changes what agents can do across sessions and tools. Chat history is a symptom, not a system.

A confirmation dialog collects a decision. The execution system needs to know which intent, revision, arguments, and destination that decision authorizes, and whether it has already been consumed.

When the operator is the user, a single binary on their laptop beats a hosted control plane more often than the industry admits. Iceberg + DuckDB on hardware you already own does more than expected. And the trade-offs aren't where you'd guess.

Saving the conversation preserves what was said. Recovering an agent requires a separate account of what was authorized, what ran, and which external effects are still uncertain.

Partitioning strategies, secondary index trade-offs, rebalancing, and service discovery. The four decisions you actually have to make when a single node stops being enough. Plus what Discord learned moving trillions of messages from Cassandra to ScyllaDB.

A model can choose the next action. Something else has to own permission, execution, recovery, and proof that the action happened. That system is where an agent becomes a product.

Two storage decisions sit at the heart of any local-first analytics tool. Get them right and you ship as a single application the user can trust on their own machine. Get them wrong and you've reinvented a hosted service somebody has to operate.

A starter cheatsheet for working in a shell. Terminal controls, file management, permissions, process inspection, services, and the small set of commands you'll reach for daily. Written for someone moving from a GUI-only OS.

A learning roadmap I wish I'd had when I started. Programming & data structures, SQL and database internals, big-data systems, data stores, and the DevOps surface area you can't avoid. Five years later most of it still holds.

A walkthrough of three-tier web architecture, request lifecycle, and the trade-offs between single-server, multi-server, and serverless deployments. Notes from when I was learning to design backend systems.

A practical walk through local, centralized, and distributed VCS, then a working command reference for Git. Branching, stashing, the commit object model. Written for someone learning the tool from first principles.