I build systems that prove themselves. Six of them are live, publicly reachable, and each ships a system card — a printed-quality walkthrough of the architecture and the evidence behind its numbers.

What follows is five system plates (LifeQuest and AutoML share the last), plus one for the habit that runs underneath all of them, between an opening and a colophon. Each shows the claim, then the mechanism that would catch the claim if it were a lie.

A neural network written from scratch in C++ — no framework — with hand-written SIMD kernels for AVX-512, AVX2 and NEON. On main, the WebAssembly build carries no intrinsics of its own: under Emscripten every ISA predicate misses and the scalar path is autovectorised by -msimd128 (CMakeLists.txt:279). The branches are #if/#elif, so one binary compiles one path and nothing cross-checks them.

The live page and the repo diverge here, so be exact about which you're looking at. getglyph.vercel.app does fetch and instantiate WebAssembly — /wasm/fast_mnist.wasm, 46,960 bytes, application/wasm, and it is a SIMD build — but it came off a branch carrying real wasm_simd128 intrinsics. What you can reproduce from main is the autovectorised one, which is not quite what the link serves. (An earlier revision claimed the opposite — that no .wasm was fetched at all — and a later one put a SIMD-instruction count here. The first was wrong; the second I could not reproduce twice with the same method, so it is gone rather than rounded.)

97.01% on the 10,000-image MNIST test set — 9,701 right, so 299 wrong.

That same test set also selected the checkpoint and triggered early stopping (apps/train_model.cpp:219-243), so treat it as a training-time number, not a clean held-out one. The run wasn't seeded either. The grid above draws all 299 — each mark the true label of an image the model missed.

live · system card · repo

Parallel, gzip-compatible compression on JDK 25: one virtual thread per block, a bounded in-flight window so peak memory is independent of file size, and memory-mapped input via the Foreign Function & Memory API.

The checksum is hand-vectorised — so it is checked bit-identical against java.util.zip.Adler32 across every input the test suite throws at it. The output is a byte-valid single gzip member any tool can decompress.

422 MB/s parallel vs 66.2 MB/s single-threaded — 6.4× on an M1 Pro (10 cores). That is a 3-fork JMH run with 99.9% confidence intervals spanning ±0.7% (single-threaded) to ±6.9% (the vectorised checksum), committed at benchmarks/jmh-results-rigorous.json with the machine spec beside it, so you can re-run it and check.

And the row that stays in the table because it's true: the hand-vectorised Adler-32 reaches 4.26 GB/s, while the JDK's own native intrinsic does 14.06 GB/s. I don't beat it. The SIMD result is honest against the scalar baseline (2.80× on the 3-fork run, 2.92× on the quick one — they disagree at the second figure, and that spread is the uncertainty), and the intrinsic is printed next to it as the reference it loses to.

live · system card · repo

A sentence typed the way you would say it becomes a calendar entry. The parser runs four stages — chrono, hashtag, priority, language — and every extracted span records the parser that produced it — source is a required field on every tag, and conflict resolution depends on it, so a wrong answer is always traceable to the stage that caused it.

36 API handlers bundled into a single serverless function, to live inside Vercel's 12-function cap without giving up routes.

live · system card · repo

Your inbox already holds the verdict on most applications you've sent. A three-layer cascade reads it: 201 regex rules → e5 embeddings → a fine-tuned SetFit head, cheapest first.

0.979 macro-F1 on a 96-message, 8-class evaluation set, and CI fails the build below 0.95 with a real non-zero exit.

Worth being exact, because the number and the picture don't quite match: that score is generated with the deterministic profile, which switches the SetFit head off and empties the embedding store — so it measures the regex layer alone, and the rules-only baseline reproduces it to the last digit. The full three-layer cascade's own score, 0.9583, survives in exactly one line of prose (docs/ML_EXECUTION_TRACKER.md:378) because the run that produced it was overwritten by the deterministic re-run. I can hand you an artifact for 0.979 and not for 0.9583, so 0.979 is what the plate draws, labelled for what it actually measures.

Anything under the 0.85 confidence gate is not guessed at — it goes to a human. The model is allowed to say it doesn't know.

The fine-tuned head exports to int8 ONNX (90.4 MB → 22.8 MB) and runs in your browser: the server ships the weights once, then classification happens in your tab and nothing you paste leaves it. allowRemoteModels = false keeps the model local. That in-browser build is the Hugging Face Space; the [live] link below runs the rules layer only.

live · system card · repo

Application code that filters by user is code that has to remember to filter. So the database enforces it instead: PostgreSQL Row-Level Security, FORCEd on every tenant table, with the app connecting as a dedicated non-BYPASSRLS role and the request identity carried as a transaction-local GUC.

The test that matters runs a raw, unfiltered SELECT * FROM tasks as user B. It returns user B's rows only — because the database refused, not because the query remembered. Being exact: the migrations are hand-run, and production still connects as the owner role, so today this is proven in CI against ephemeral Postgres rather than enforced in the deployed database.

Auditing my own work, I found seven IDOR vulnerabilities in Cadence — endpoints where any authenticated user could read or delete another user's records by id. A later audit found an eighth of the same shape that the first sweep missed: TagService inherited the base class's unscoped WHERE id = $1, so any user could read or delete any other user's tag. All eight are fixed. Seven carry a regression test asserting the scoped SQL; the task-lists one does not yet. The tag one is worth naming, because its existing test asserted the vulnerable query and would have reported green forever.

the migration · the app role · the isolation suite

LifeQuest turns real-world routines into tracked quests with tiered progression — built for people rebuilding structure, whether after a layoff or in retirement. Tauri + React client, NestJS + Prisma API.

Agentic AutoML takes a dataset and returns a deployed model: LangGraph orchestration over an MCP tool registry, Python executed in a hardened Docker sandbox — non-root, read-only rootfs, an --internal Docker network with no outbound route (the beta deploy defaults to bridge), capped memory and CPU — and human approval gates before a preprocessing step is committed and before a model is trained. Worth being exact: preprocessing runs the code before it asks, so the gate protects what gets persisted rather than what gets spent — and whether a step needs approval is itself proposed by the model, with a keyword fallback. Senior design at Miami University, co-built with Shree Chaturvedi.

LifeQuest · system card — AutoML · system card