Seven projects. Zero vaporware.

1. Build the generation core first. AI-generated multi-page sites with real SEO, favicon, and export from day one — not a prototype bolted onto a template picker.
2. Guard the API budget. Per-IP rate limiting on the generation endpoint so a stranger with the URL can't run up the AI bill.
3. Make generated sites feel real. Working contact forms, real images, real typography and micro-interactions instead of generic placeholder blocks.
4. Track cost per generation. Usage and cost tracking on every AI call so the unit economics of the business are visible, not guessed at.
5. Protect ownership. Per-site management tokens so sharing a preview link can't hand over control, plus a password gate before generation.
6. Pivot to a real business model. Renamed from an internal codename to Webformer, moved to a done-for-you service with owner login, logo/social links, and customer photo uploads.

Built with: Node.js, Express, Claude API (site generation), Stripe (checkout), Nodemailer.

1. Start in a sandbox. Ran multiple versions in parallel against live data with nothing at risk before going live.
2. Make the simulation honest. Modeled real-world friction into the sandbox so a test win actually meant something.
3. Harden before going live. A dedicated pass on safety, efficiency, and monitoring — before the first live run, not after.
4. Find the bugs real use exposes. Race conditions, auth gaps, and edge cases that only break under real load.
5. Keep the kill-switch usable. A safety trip can pause new actions, but it can never leave the system stuck halfway.
6. Layer in a second opinion. A second, independent model reviews every action before it runs — no single source decides alone.
7. Tighten the false positives. Iterated until the safety systems stopped overreacting to noise.

Built with: Node.js, Express, Claude API (second-opinion review), Telegram (alerts).

1. Wire up a real data feed. Pulled live data from a public API and normalized every source into one shape, so the rest of the bot doesn't care where a result came from.
2. Never let a hung request stall the scheduler. Wrapped every fetch with an 8-second timeout — one slow upstream call used to be able to freeze the whole scheduled run.
3. Add a fallback so updates never just go dark. If the main feed is unreachable or the key runs low, the bot reshapes a free backup feed into the same format and keeps posting.
4. Watch the API budget before it runs out. A quota check on every response fires a low-balance alert once remaining requests drop below a threshold, instead of finding out when updates silently stop.
5. Turn data into an actual prediction, not just a number. A confidence floor decides whether a prediction is worth tracking at all, with a stricter bar where outcomes are more volatile.
6. Grade yesterday, automatically. A separate scheduled job checks results the next morning and posts a scorecard of how the predictions actually did, so the track record is real and public, not cherry-picked.
7. Ship it on a schedule, not on demand only. Daily recap runs on cron at 9am ET into a dedicated channel, with a slash command for anyone who wants a live pull in between.

Built with: Node.js, discord.js, node-cron, public data APIs (with a backup feed).

1. Ditch the native dependency that didn't fit the box. First pass stored data in SQLite via a native module; the server's Node version couldn't compile it against the current build toolchain, so it switched to plain JSON files — simpler, zero compilation risk, plenty fast at this scale.
2. Make the deadline mean it. A sweep on a 60-second interval checks every open project's deadline and permanently deletes it — and its replies — the moment it expires unfinished. Verified by manually backdating a project's clock and watching it actually get destroyed.
3. Guard the open door. Since any agent can register with no approval step, capped registrations per IP and writes per API key before the first real signup from outside the household ever happened.
4. Fix what "live" actually requires. A bare IP address on a non-standard port with no TLS certificate tripped browser and ISP phishing filters — agents and the page it was pointed to needed to live under a domain with a real certificate, not a fresh DNS entry.
5. Ride an existing certificate instead of minting a new one. Mounted it as a reverse-proxied path on Webformer's already-issued domain and TLS cert rather than standing up new DNS and a Let's Encrypt cert for a side project.

Built with: Node.js, Express, JSON file storage, express-rate-limit.

1. Find the raw data. Codex requires a login, but the underlying neuron skeletons sit on a public Google Cloud bucket in Neuroglancer's precomputed format, and the cell-type annotations are open on GitHub.
2. Write a shard reader. The skeletons are packed in a sharded, hashed, gzip-compressed binary format — a small Python reader (MurmurHash3 + HTTP range requests) pulls a single neuron without downloading the whole bucket.
3. Curate for story, not volume. Hand-picked ~50 neurons across eight systems so each one means something — the Giant Fiber escape neuron, compass EPGs, clock neurons, dopamine reward/punishment cells.
4. Shrink it for the web. Walked each neuron's branch tree and resampled along path length, cutting 2M+ raw vertices to 180k while keeping every branch point. Pre-gzipped and decompressed in-browser with DecompressionStream.
5. Render it. Three.js line segments with additive blending on a dark stage, OrbitControls, raycast hover picking, and a system-isolation mode that dims everything else.

Built with: Python (data pipeline), Three.js, FlyWire FAFB v783 (Dorkenwald et al. & Schlegel et al., Nature 2024).