┌─ 404human ─────────┐
  │  $ whoami          │
  └────────────────────┘

hey, I break things.

Then I fix them, and write down what I learned. Mostly Rust: runtimes, background jobs, AI tools. All in public, mistakes included.

Running now

What’s actually in flight — drawn the way it’s thought about: as live processes, not as a bio.

$ ps aux | grep -v idle

PIDPROCESSSTATEWHAT
101 colophon running A Rust + Svelte CMS that can prove what it published, designed in the open and built one proven milestone at a time. — P6 · 24h soak, 0 tests
102 service-monitor running A Rust uptime monitor that tells the truth, built one tested checkpoint at a time. — M5 · soak, 137 tests
103 js-runtime running A purpose-built JavaScript host in Rust — V8 through deno_core; the engine borrowed, the capabilities and lifecycle ours. — M7 · 7.3, 84 tests
104 minibtc running A Bitcoin-style blockchain built from scratch in Rust — consensus through the wallet UI; every blueprint gate passed. — P13 · ui, 167 tests
105 durable-runner running Acknowledged work survives restarts — journaled, crash-tested, and now load-measured honestly: the sustained gate is red and being root-caused. — D4 · 0.5
106 rust-knowledge-base complete Claude Code studying the whole Rust Book, checked by exams the AI can’t see. — final exam 59/59
107 writing always Every experiment written up here, including the parts that didn’t work. — 114 write-ups on file

Projects

ProjectYearStatusWhat it is
MiniBTC 2026 complete A Bitcoin-style blockchain built from scratch in Rust — consensus, UTXO set, P2P, mining, an HD wallet, JSON-RPC, an explorer and an MCP server that can inspect the chain and draft payments but never spend without a human. Every blueprint gate passed.
Durable Runner 2026 in progress A background-task runner where accepting a job is a durable commit: a framed file journal, one writer, at-least-once attempts, and crash recovery that admits what it cannot know. Rust, built in the open.
jsrt 2026 roadmap done A JavaScript runtime that is a host, not an engine: V8 through Deno's own deno_core, Rust owning capabilities, the lifecycle, and honest errors. Built to operate a real app, one proven milestone at a time.
Colophon CMS 2026 in progress A content management system that can prove what it published and survives being killed at any moment. Rust and Svelte, open source, every step logged here.
Service Monitor 2026 feature-complete Keeps an eye on your websites and tells you, honestly, when something breaks. Written in Rust, built in the open, one tested step at a time.
Teaching an AI Rust 2026 write-up Claude studied the entire Rust Book, then took hidden-test exams with no compiler. 59/59 on a final test full of decoys.
This site 2026 live This portfolio and build log: built with Zola, drawn like a small control room, with real numbers from the posts. No tracking.
flagship — Colophon

A CMS where “published” is a receipt, not a spinner. In a book, the colophon is the note at the back saying how, when and by whom it was printed. This does that for a website: every publish is a numbered release, and a probe reads the release marker off the live page before the product calls it done.

PostgreSQL is the only authority — RLS decides who sees what — outbox commits intent before any external call — release generations only move forward.

[ The build log ] — every step, including the mistakes.

Numbers I can show, not adjectives

House rule: no claim without an executed run and stored evidence. These are from committed result files on laptop-class hardware — development observations, never presented as production capacity.

MeasuredNumberWhat it does and doesn’t prove
Warm baseline, 30 min sustained 540,063 req 300/s with zero failures on this machine. Proves the path holds steady load; says nothing about your hardware.
Noisy-agent isolation 600 refused/s A token past quota is throttled inside its own auth lookup while editors beside it hold their latency.
Import at true scale 10,000 records A real import, not a loop over a sample labelled “scale”.
Disaster restore drill 400 s Encrypted capture to serving on clean infrastructure — rehearsed for real, not documented in hope.
Full load runs, every scenario ≥ 1,000,000 req The standing bar for anything that serves traffic; misses fail and get investigated, not re-run till green.
Hidden-test Rust exam 59/59 The AI couldn’t see the questions or run a compiler. Decoys included.

How the work is judged

Proof over breadth.
A feature counts when its failure behaviour is tested and the evidence is stored — never when the screen exists. Every feature ships with the trio: regression tests in CI, a separate testbed app driving the real HTTP API, and a load scenario with committed results.
Truthful states.
“Accepted” presented as “done” is the industry’s favorite bug. Here an accepted publish is pending until a probe sees it live, and an unmeasurable check stays uncertain rather than borrow confidence.
Kill it at any moment.
Crash tests have catalogue numbers (F01–F09 and counting). Bugs get a replayable seed: colophon-sim --seed N --trace. Killing things on purpose is the demo, not the edge case.
Bounded everything.
Every queue, body, page, cache, retry loop and pool has a limit and a deadline — a bound you can’t name is an outage you haven’t met yet.
No AI hype.
Agents and scripts work through the same API and the same permissions as everyone else — draft-only, on budgets reserved in Postgres, never allowed to approve their own submissions. Safe automation is a tested milestone, not a paragraph.

Learning

Concepts worked through from the beginning, with small examples and questions still open.

Model engineering from the beginning

Learning how models are built, trained, tested, and improved, starting with one adjustable number.

9 chapter notes available · learning in progress.

[ Chapters ] [ Roadmap ]

All learning tracks →

Writing

Experiments, learning notes, and the things that went wrong along the way. Recent posts:

And each project keeps its own build log — Colophon, Service Monitor, jsrt, MiniBTC, Durable Runner — every entry written up, numbers included. All writing also lives in the feed.

Asked plainly

Why build in the open, including the mistakes?

Because “proof over breadth” can’t be claimed, only shown. A build log that includes the failures is the difference between saying a system is reliable and letting you check.

Is any of this usable yet?

Honestly labelled: Colophon is pre-0.1 — it runs on my laptop and CI, and its own site says so. The service monitor has an installed release and its 24-hour soak is evidenced. jsrt's roadmap is done — host, capabilities and supervisor, all with committed load numbers. Nothing here is marketed ahead of its evidence.

Why Rust?

Because “bounded everything” is easier to keep than to promise: one type system for the error envelope, explicit deadlines on every I/O await, compilers that refuse what production would regret, and simulators that replay failures deterministically.

How minimal is this site, really?

Zola generates it; the output is one documented stylesheet (width, font, spacing — all of it), one small script for the theme toggle, no tracking, one self-hosted font. Layout is tables, accordions are <details>, the ticker is a CSS-scrolling track. View source; it fits in your head.

Find me

Site404human.dev — this one, generated by Zola in Rust
GitHubgithub.com/akira-shirase-oss — every project above, public
X@akirashiraseoss — the growth program is itself an experiment