Development blog

How Obituary got built

Every decision, every rework and every trap we hit, written down by development date. The pictures are the terminal output, test results and screenshots from the day.

  • 22 posts
  • Nov 7 – Nov 21
  • About 196 min of reading

Latest

Timeline

By development date, newest first

    • The landing page's first screen: mobile Lighthouse from 47 to 99

      Late on 20 November the landing page's first screen became the desktop window's real components, and on a phone Lighthouse gave it 55. By 2:41 in the morning of 21 November the same local build scored 99 to 100 under the same simulated conditions. This post covers the three steps of those three hours: first-screen text that arrives with the HTML, less work before the first screen, and hydrating only the first screen.

      Post 207 min read

    • Ten languages: keeping the README, the website and the software readable in every one

      From the afternoon of 20 November to the early hours of 21 November, Obituary got a README in ten languages, a single message catalog for the software, and website pages in ten languages. This post covers how the ten stay in step: one source file, a fixed glossary, diagrams whose text is measured in a browser, a list of what is never translated, and a line-by-line read of each language.

      Post 198 min read

    • The China mirror and the release pipeline

      GitHub can be unreachable or slow in mainland China. On 11 November Obituary got a mirror there: one domain split by network route, and an installer and update check that fall back to the mirror when GitHub does not answer. How the archives reach the mirror then changed twice, from the server pulling them from GitHub to the release pipeline pushing verified files up, with the server only rechecking and publishing by rename.

      Post 186 min read

    • How backticks in release notes wiped our main checkout

      On the evening of 19 November 2026 a Codex worker put release notes containing backticks into a shell command and emptied the project's main checkout. The delete guard saw only text; the failure happened when Codex on Windows handed the command to another shell. How it happened, our first wrong diagnosis, the 1.4.3 rule, and the sandbox we tested and set aside.

      Post 1715 min read

    • Building with AI: who decides, who executes, gates and evidence

      Most of Obituary's code was written by AI: a coordinator splits tasks and verifies findings, workers implement in their own workspaces, and reviewers are read-only. This post covers how that division of labor took shape, why the briefs ask for gates and evidence, and how we became the first victims of the very problem Obituary is meant to solve.

      Post 167 min read

    • Doing nothing when idle: zero wakeups for a resident process

      During a check on 14 November the resident obitd was using about 0.37 of a CPU core while idle, yet a measurement taken straight after showed 0.02. We treated it as a load-dependent problem and reproduced it, and the root cause that pprof found was not where we expected. After the fix, a stream of ledger writes went from about 2.9 cores to 0.2 and idle use from 0.15 cores on average to 0.03, and the resident process wakes only on events.

      Post 156 min read

    • Automatic registration: from asking first to off by default

      On 12 November we first required that every proposal Obituary hands out be safe to approve. On the evening of 14 November tiered automatic registration went live, that night we saw four kinds of problems on our own machine, and in the early hours 1.3.0 made automatic registration off by default. Less than seven hours separate 1.2.0 from 1.3.0.

      Post 149 min read

    • macOS and Linux: no rename by handle

      On Windows a burial checks identity and renames on the same handle, while rename on macOS and Linux knows only a parent directory and a name. On 10 November we decided not to relax that promise. Two days later we switched to moving first, then verifying, and putting the file back if it does not match, moved the whole test suite onto CI for both platforms the same day, and released 1.1.0 on 13 November.

      Post 137 min read

    • When a product story became a requirement: grave notices and Docker containers

      In the early hours of 11 November a line from a product story was checked against the code and turned out not to be true yet, so it became a requirement: when an agent touches a path that has been buried, Obituary tells it on the spot. Right after, another annoyance became a requirement too: Docker containers started by an agent are stopped at expiry and removed only after the retention period.

      Post 128 min read

    • 1.0.0: the first release

      Obituary 1.0.0 was published at ten to eight on the evening of 11 November, less than four days after the first commit on the night of 7 November. This post covers why the first version went straight to 1.0.0 and only for Windows, how the installer checks SHA-256 before it installs anything, why the first sentence for installing Obituary is addressed to an agent, and the 1.0.1 that followed less than five hours later.

      Post 117 min read

    • Tests our machines could not run: two tiers

      Most of Obituary's tests touch the real file system, Git and subprocesses. A package that finishes in a little over a minute on an idle CI machine timed out on a local machine with a dozen workers running. On 10 November we split testing into two tiers, with only the fast one run locally and the full suite run only in CI, and made sure no test package can touch the real user environment.

      Post 106 min read

    • Tray, window and context menu: the half for humans

      Obituary has been built for agents from the first day, but approving a proposal, browsing the graveyard and resurrecting a file always end up with a person. On 10 November we added the half for humans in one day: a resident tray process, a five-page window, the classic context menu, folder policies and burial dates in Explorer.

      Post 98 min read

    • Editing someone else's config file without breaking it

      Obituary has to write itself into the configuration files of many agents, and an editor or the agent itself can rewrite those files at any moment. On 10 November we went through three rounds on this, and each one replaced a name with a handle: verify before writing, use one handle for the whole life of the temporary file, and create the temporary file relative to a pinned parent directory.

      Post 88 min read

    • The ledger: JSON, SQLite, and a rewrite we did not merge

      On 9 November we evaluated replacing the JSON ledger with SQLite. In the prototype scattered commits were ten times faster, but the first real implementation was slower than JSON, and after two rounds of profiling the branch was parked. What made the ledger fast was batched reaping, a more compact format and a graveyard split into its own snapshot.

      Post 77 min read

    • Thirty agents: hooks, plugins, or rule files plus MCP

      At first Obituary connected to two agents, Claude Code and Codex. On the afternoon and evening of 9 November we turned the integration layer into a registry of adapters and connected 29 of them that day, with the 30th following the next morning: 17 through native hooks, 9 through plugins and 4 through rule files and MCP alone. This post covers how the three kinds of connection differ and how we report what each host can do.

      Post 68 min read

    • Why Obituary uses Go instead of Rust

      The first plan for Obituary recommended Rust, and we switched to Go on the first night. When the code reached 13,600 and then 64,000 lines, we did the rewrite math twice more. What the case for Rust rested on, the constraints that kept us on Go, and the fuzzing, benchmarks and parallel tests the question pushed us to add.

      Post 517 min read

    • Twelve review rounds: how to trust a tool that deletes files

      On 8 November the three phases of Obituary went through 40 review rounds: finish a phase, have reviewers read it, verify every finding, fix with tests that fail first, then bring in fresh reviewers until a round turns up nothing serious. How the loop runs, what each round was looking for, and when to stop.

      Post 310 min read

    • Lifespans, a graveyard, cremation: why not just use the Recycle Bin

      Obituary splits one deletion into five steps: register, expire, bury, resurrect, purge. The first version handed expired items to the system Recycle Bin, and on the first night we started replacing it with a graveyard of our own. Why we replaced it, how the graveyard makes sure what comes back is what was taken, and where the Recycle Bin is the better choice.

      Post 211 min read