Projects
Things I build for myself.
Outside of client work, I build things that solve problems I actually have. All three projects here were built using Claude Code, a CLI-based AI development agent with full file access, browser preview verification, and structured project context that survives across sessions.
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 metrics, 524 nights of sleep staging, and 458 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 entire project was built using Claude Code, a CLI-based AI development
partner with direct access to the file system. The project is guided by a
CLAUDE.md file that the agent reads at the start of every session:
it contains 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.
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.
This site was designed and built using Claude Code from the ground up. The design system, the component architecture, the typography, the color tokens, the blog infrastructure, the contact form on Cloudflare Pages Functions. All of it was built through an iterative process with an AI development partner, not a template or a theme.
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.
Claude Code is a command-line tool that runs as a full development agent: it
reads, edits, and creates files, runs shell commands, starts servers, and
verifies results in the browser. What makes this approach powerful is the system
behind it. Structured CLAUDE.md files, a persistent memory
directory, a writing style guide the agent references before touching any copy,
and a project plan that stays current. The result is a development workflow where
context compounds across sessions instead of starting over each time.