Projects

Share a real terminal with anyone using a 6-digit code. No port forwarding, no VPN, no tunnel service.

• 6-digit pairing code
• ·0 bytes of terminal data through my servers
• ·P2P after handshake
• ·DTLS-encrypted DataChannel

Hardest part. Signaling must be centralized, but terminal bytes must not be. The Durable Object relays only SDP and ICE, then drops out of the path entirely — so nothing I run ever sees your shell. The /switch command was the harder half: both peers run their own PTY, so control handoff means negotiating which side renders and which side forwards keystrokes.

TypeScript · node-pty · WebRTC · Cloudflare Workers + Durable Objects · Hono

Postgres-backed job queue with lease-based semantics and crash recovery. Built to understand the failure modes River, Sidekiq and BullMQ solve.

• at-least-once delivery
• ·35s worst-case crash recovery
• ·30s lease, 10s heartbeat
• ·zero duplicates via idempotency key

Hardest part. Chose FOR UPDATE SKIP LOCKED over NOWAIT — NOWAIT raises on lock conflict and forces error handling on every poll, while SKIP LOCKED simply moves to the next row. Crash recovery is a lease plus a reaper rather than LISTEN/NOTIFY: polling costs latency but survives a worker that dies holding a job. Worst-case recovery is bounded at lease duration + reaper interval, which is why both are configurable.

Go · Postgres · pgx/v5

Fault-tolerant crawler with URL leasing, per-host politeness, distributed dedup and full-text search across workers.

• 20 concurrent requests per worker
• ·1M-entry bloom filter
• ·300s URL lease TTL
• ·5-level crawl depth

Hardest part. Politeness and throughput pull in opposite directions. A per-host scheduler honours crawl-delay from robots.txt while Redis Streams consumer groups keep workers saturated on other hosts, so one slow domain never idles the fleet. Dedup is two-layer — bloom filter for the cheap negative, Redis SET for truth — plus simhash with a Hamming threshold to catch near-duplicate content that URL normalization can't.

Python 3.11 · FastAPI · Redis Streams · Postgres · Elasticsearch · Docker Compose

Reed-Solomon erasure coding written from scratch over GF(2^8) using Cauchy matrices. The 5-of-9 scheme S3 and MinIO use.

• 5-of-9 Reed-Solomon
• ·survives any 4 of 9 shards lost
• ·GF(2^8) arithmetic
• ·no external coding library

Hardest part. Cauchy matrix construction is what guarantees every K×K submatrix is invertible — get it wrong and specific shard-loss combinations become permanently unrecoverable, which a happy-path test will never catch. Decoding is Gaussian elimination with partial pivoting inside the field, where addition is XOR and every multiplication is a log/antilog table lookup rather than a CPU instruction.

Go · Galois Field arithmetic

Intercepting HTTPS proxy that mints certificates on the fly from a local CA and inspects traffic mid-tunnel.

• on-the-fly leaf cert generation
• ·per-host in-memory cert cache
• ·HTTP/1.1 and HTTP/2
• ·CONNECT tunnel interception

Hardest part. HTTP/2 can't be inspected the way HTTP/1.1 can. Detection happens on the connection preface (PRI * HTTP/2.0) and then routes through a reverse proxy instead of the byte-level inspector. Leaf certificates are cached per host because minting a keypair on every TLS handshake turns the proxy itself into the bottleneck.

Go · TLS · x509 · HTTP/2

Reverse-proxy load balancer built from net/http, with active health checking and a tuned transport.

• round-robin across healthy backends only
• ·active /health polling
• ·race-detector clean
• ·tuned keep-alive transport

Hardest part. The backend pool is read on every request and mutated by a background health checker, so the hot path had to stay correct without serializing behind a mutex per request. Health checking is active rather than passive on purpose — a dead backend is evicted on the next poll cycle instead of after a user absorbs the error.

Go · net/http · httputil.ReverseProxy

Paste SQL, get a real execution plan as an interactive tree, plus heuristic findings and schema-grounded rewrites.

• EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)
• ·read-only txn, always rolled back
• ·schema-grounded AI rewrites
• ·collapsible per-node plan tree

Hardest part. Executing arbitrary user SQL against a live database without letting it mutate anything. Read-only statements run inside BEGIN; SET TRANSACTION READ ONLY; and are unconditionally rolled back; anything else degrades to a plan-only EXPLAIN and is never executed. Rewrites are grounded in the actual plan and live schema, so suggested indexes reference columns that exist instead of ones the model imagined.

Next.js · Postgres · LLM

A build-and-deploy pipeline in Rust, wiring Nixpacks to BuildKit. Shipped in a day, then audited publicly.

• Rust build orchestrator
• ·Nixpacks + buildctl + BuildKit
• ·one-day build, then a written audit
• ·3 posts on the failure modes

Hardest part. The real work was understanding how Nixpacks, buildctl and BuildKit actually hand off to one another — Nixpacks generates a plan, buildctl drives BuildKit, and the seams between them are where everything broke. The first version worked and was wrong in ways I only found by writing the audit afterwards; phase two is the corrections.

Rust · Nixpacks · BuildKit · Docker

Browser extension that redacts PII before it reaches an AI chatbot. Everything runs locally in a Go WASM vault.

• 100% client-side, zero network egress
• ·Go → WASM redaction vault
• ·one shared instance across all contexts
• ·capture-phase keypress interception

Hardest part. A single WASM instance has to serve both the content script and the options page, so it lives in a Chrome offscreen document and both sides talk to it over chrome.runtime.sendMessage. Redaction fires on keypress during the capture phase — it must finish before the host page's own submit handler observes the event, otherwise unredacted text is already in flight.

Go 1.26 → WASM · TypeScript · Vite · Chrome MV3

MCP server that indexes a repo two ways — AST symbol graph and semantic embeddings — so agents can actually navigate code.

• dual pipeline: AST + semantic
• ·3-tier search fallback
• ·call-graph traversal by depth
• ·11 MCP tools exposed

Hardest part. Semantic search fails quietly on identifier-shaped queries — ask for a function name and embeddings return vibes. Retrieval is hybrid: embeddings first, then ripgrep → ugrep → grep, then SQLite keyword match, so an exact symbol still resolves. Symbol graph lives in SQLite, embeddings in Chroma, because the two have completely different access patterns.

Python · SQLite · Chroma · MCP · AST