Projects
Things I build for myself.
Outside of client work, I build things that solve problems I actually have, or that are just fun to build. All four projects here were designed and directed by me and built with Claude Code, a CLI-based AI development partner with full file access, browser preview verification, and structured project context that survives across sessions.
122 scenarios and endings, selected live by a rules engine that reacts to your stats and choices. A seeded daily run, Today's Shift, gives everyone the same start each day.
Reply All is a text-based workplace RPG that lives right on this site, with Google sign-in so a run saves across devices. It's not a fixed branching story. Every scenario, NPC, and ending is a self-contained file that declares its own eligibility rule: which stats, flags, or relationships have to be true for it to show up. A client-side engine filters the whole pool live and picks what's next, so two players rarely see a run play out in the same order.
The backend runs on Cloudflare Pages Functions and D1: a Google OAuth handshake with no passwords stored, signed session cookies, and a save that persists per account. A build-time validation step walks every scenario and fails the deploy if any of them reference a flag or item that nothing in the content ever actually sets, catching a broken reference before a player ever could.
I designed the whole system: a rules-based content pool instead of a branching tree, the requires/effects schema every scenario is authored against, and a crossroads pattern that gives a player a real moment to back away before an ending locks in. Claude Code implemented it end to end: the OAuth flow, the D1 schema, the selection engine, the build-time validation, and the first pass of NPCs, scenarios, and endings written against the rules I'd set.
16,000+ daily metrics over 18 months, calibrated against a clinical sleep baseline.
I built this because I wanted to actually understand my health data. Not just glance at rings on a watch, but see patterns across every signal I generate over time and measure the real impact of treatment decisions.
It's a Python-based data warehouse that pulls from Apple Watch, iPhone health metrics, sleep tracking, workouts, nutrition logs, and a medical device. Custom importers handle each source, with deduplication logic to resolve the messiness of multi-device recording. Everything lands in a local SQLite database with 18 months of history: 16,000+ daily readings across 72 signal types, 542 nights of calibrated sleep staging, and 479 logged workouts.
The analysis side generates reports for HRV, resting heart rate, sleep architecture, SpO2, VO2 max, blood pressure, weight trend, and training load. Sleep stage data is calibrated against a clinical in-lab baseline. The Apple Watch systematically under-reads deep sleep. I measured exactly how far off it is against a polysomnogram and built a correction factor into the database. The milestone system lets me mark treatment start dates and run before/after comparisons on any metric.
The system recently gained a coaching layer built on Peter Attia's Medicine 3.0 framework. A framework document maps each of Attia's five levers (exercise, nutrition, sleep, emotional health, exogenous molecules) to my actual data and verified numeric targets. A Python scorecard auto-generates from the database weekly: current value vs target, a status, and a trend arrow for every tracked metric. A living action plan translates the gaps into a plain-language weekly prescription, including a single highest-leverage focus for the week. A Monday morning automated routine handles everything: import, regenerate, review, update, summarize. The plan stays current with no manual effort.
I designed the schema, the calibration approach, and the coaching framework;
Claude Code executes against them. A CLAUDE.md file that the agent
reads at the start of every session holds the full database schema, import
workflow, clinical context, query patterns, and calibration notes. Each session
picks up exactly where the last left off. That persistent engineering context is
what makes complex, multi-file Python work possible at this scale.
8 linked note types, auto-committed to a private repo every 15 minutes.
The foundation is About Me.md: a document Claude Code reads at the
start of every session that describes who I am, what I value, and how I think about
my career. Not a work log. A personal context layer. From there, the vault is built
around eight interconnected note types: Daily Logs, Big Wins, People, Projects,
Companies, Goals, Action Items, and Decisions. Everything links. A log entry links
to the company, project, and people in the room. A Decision, written as a proper
Architecture Decision Record with context, alternatives considered, and consequences,
links to the project and people it came from. That relational structure, built on
Obsidian wikilinks, is what makes context compound over time instead of scatter.
Two Dataview dashboards aggregate across the vault automatically. The daily dashboard shows open action items, active goals, and a two-week energy trend. The strategy dashboard surfaces neglected goals (active goals with no daily log entry in 14 days) and network atrophy (contacts with a regular cadence who are overdue). These things don't announce themselves. The dashboards find them.
Daily capture is a custom Claude Code skill. Drop in a freeform brain dump and it produces structured Obsidian notes: projects touched, goals advanced, wins flagged, action items confirmed. The vault auto-commits to a private GitHub repo every 15 minutes via the Obsidian Git plugin. Nothing is lost.
The daily log skill is a Markdown file that loads into Claude Code each session, carrying the full workflow instructions, inference rules, and Obsidian file paths. Writing it required designing a confirmation flow that asks as little as possible and defining exactly what "sounds like a win" means in practice. I designed every step. Claude Code reads and writes the Obsidian Markdown files directly. No intermediary required. New context captured today becomes a memory the system uses tomorrow.
13 automated tests guard every deploy, running in CI on every push.
There's no template or theme under any of this. The design system, the component architecture, the typography, the color tokens, the blog infrastructure, the contact form running on Cloudflare Pages Functions: I designed every piece, and Claude Code built it out through an iterative back and forth.
The workflow looks like this: design decisions get captured in a structured memory
system of Markdown files that persist across sessions. There's a
CLAUDE.md in the project root, a memory index that tracks
decisions made about writing style, design direction, and copy rules, and a
project file that documents what's been built, what's in progress, and what
comes next. When a new session starts, the agent loads that context and continues
exactly where the last one left off.
Every visual change is verified in a live browser preview before it's called done. The agent runs the dev server, takes screenshots, inspects the accessibility tree, and confirms the output looks right. It's the closest thing to pair programming I've found, with a partner who reads every file before touching anything and never forgets the project history.
Built on Astro 5 with static output, deployed on Cloudflare Pages, with fully
self-hosted fonts. The Playwright suite covers the pages and layouts that matter,
so regressions get caught before they ship. Open Graph images are generated at
build time with Satori. Behind it is a persistent
memory system of CLAUDE.md and Markdown notes that carry design
decisions, writing style, and project history across sessions. I make the calls;
the agent executes and keeps the context.