Stack

Every active repo, strict, run directly by Bun. One observation from 2026: agents do better in Rust because they actually run the compiler, whereas in TypeScript they skip the type check.

Runtime, package manager, test runner, and SQLite driver. It runs TypeScript without a compile step, and it is the hard constraint: nothing that needs a JVM gets in.

These were the smart-contract years.

That was the year of orchestration frameworks. My rule since then is that Python trains and TypeScript ships.

A year around the idea that prompts and agent decisions are plain data. The runtime constraint ended it; the code-is-data framing stayed.

I left it once for a mobile backend in 2025 and came back for every site since, including this one.

It is only in repos with real build graphs; the rest are plain workspaces.

The one framework layer I keep, because provider abstraction is the part a framework can solve. It sits behind one wrapper so every model call runs on a subscription.

It is in every repo, and I still wish for grammar-based validation.

Chosen over Prisma because I already knew SQL and did not want a layer that hid it.

This site. Lint is advisory in CI on purpose; a check that is red by default teaches everyone to ignore red.

Hard to make a nice video with at first. The explainer-video studio runs on it, and on the Linux box it renders faster than realtime.

Every tool in my personal system is a subcommand. The binary is the interface.

Close to the shape I want: an agent is a directory of files and the whole system is version-controlled.

Habits, relationships, the search index, every business body. Files are for what a human writes and diffs; a database is for many rows of one shape that a machine writes.

Vectors in the same file as the text. About a hundred times faster than the local-first tool I tried first.

A local file by default. One environment variable makes it a replica shared across hosts with no server I run.

The daily log is markdown and SQLite only indexes it. Event-sourced designs were rejected three times.

It holds the memory organ's graph, still registered and unused since May.

One venture ran on it in mid-2026 before moving to SQLite.

A daily money reading died once because the laptop had no network at 7:30am, and a missing datapoint looks like a quiet day. Since then nothing scheduled runs on a laptop; the Mac is authoritative and the box is a replica for compute.

The deploy layer on the box, next to a self-hosted job runner and a local container registry.

Agent sandboxes with a coding agent and Bun baked in.

It keeps run history with unlimited retention, and the daily money digest lives here.

A push to main is picked up by a runner on the box over an outbound connection. No webhooks, no open ports.

Thirty small sites up in August 2026 with a hundred planned, each a probe to see whether anyone clicks.

This site and one cohort of the business sites.

The repo never mirrors their state, because a mirror is a cache and caches drift.

A rotating credential can have exactly one writer, so the shared token store lives here.

Model calls route through one provider on the chat subscription. Headless agent calls are billed as API and treated as real spend.

Git is the convergence mechanism: uncommitted means proposed, a commit means accepted. Agents cannot delete repositories, because the token lacks the scope, on purpose.

Several branch-mutating agents in one working directory corrupt each other, because a branch switch is global to the directory.

Each PR is one reviewable idea. I review from my phone, so a small diff is the difference between a review and a rubber stamp.

A good issue is a home for convergence rather than a task. What it lacks is a long-running view of ends and monitors, something that is not a chat.

The loop as of August 2026: something becomes a Linear issue, I approve it, a cloud agent picks it up, I review and merge.

Scripts come first; the protocol wraps them for when a second harness needs the same thing.

One bot, pull-based, no server. Each business agent is bound to its own channel.

Sponsored credits were the whole reason. When they expired every call became real billing, so it went behind one switch and off, with two exceptions nothing else serves.

The design started from schemas and runtime machinery before it had touched enough reality. Replaced by a folder under git, local-first.

Fast to move with, and it limited how much I could over-schematize. It survives as the analogy for what I want to be for agents.

Schemaless felt right when I did not know what I was building. Both gone by 2026; the journals are markdown files.

Its core abstraction was the thing I kept working around, which told me it was solving a different problem than mine.

I found I could standardize the input to rich text plus attachments and let scripts decide.

It lasted two months, and the home server took that role.

A log command and a voice recorder on walks replaced it.