I build software for making complex systems easier to inspect, compare, understand, and use.

My projects tend to sit somewhere between product engineering, research tooling, creative technology, web systems, and applied AI. Across very different domains, I keep coming back to the same ideas:

• preserve evidence before interpretation
• keep provenance and history inspectable
• make workflows reproducible
• treat failure states as part of the system
• prefer durable state over ephemeral magic
• use AI as a component, not as an unquestioned source of truth
• keep tools local-first when practical

I like building things that don't just produce an answer, but let you understand where the answer came from.

A local-first website intelligence platform for collecting, preserving, comparing, and interpreting technical evidence about websites.

Site Ledger inventories pages and resources, performs static and rendered collection, captures accessibility and performance evidence, evaluates findings, compares historical states, and tracks coverage across large sites.

The project has grown into a fairly serious systems-engineering exercise involving durable background jobs, retries, lease ownership, stale-worker fencing, schema migrations, immutable evidence, compatibility-aware evaluation, recursive sitemap provenance, and deterministic comparison workflows.

Focus: website intelligence, evidence systems, background jobs, data lifecycle, accessibility, performance, full-stack product engineering

A web application for preparing video for modern website delivery.

It wraps real media-processing workflows in a usable product rather than exposing raw FFmpeg commands, with validation, job orchestration, testing, CI, and an open-source project structure intended for actual use.

Focus: media engineering, FFmpeg, web performance, TypeScript, production workflows

A provenance-first symbolic knowledge and divination system covering Tarot, the Yijing / I Ching, and Elder Futhark runes.

The interesting problem here is not generating mystical text. The application deliberately separates mechanical casting, historical evidence, editorial material, traditions, interpretations, and source provenance so uncertainty and conflicting traditions remain visible instead of being flattened into a single authoritative answer.

Historical readings remain immutable, imported corpora are validated and versioned, and AI is not allowed to silently become the source of truth.

Focus: knowledge systems, provenance, historical corpora, domain modeling, FastAPI, React, data integrity

A local-first workspace for studying how images change through repeated AI generation and editing.

Runs preserve exact prompts, settings, lineage, costs, telemetry, and generated artifacts. Users can compare frames, branch from earlier results, introduce candidate sets, select which output continues the chain, and measure perceptual drift across a sequence.

It started as a small experiment and evolved into a structured human-in-the-loop AI workflow system.

Focus: generative AI, lineage, reproducibility, human-in-the-loop workflows, telemetry, media analysis

A local workspace for extracting, editing, reviewing, saving, and exporting color palettes.

ColorCraft analyzes geometric hue relationships and contrast without pretending either measurement represents objective aesthetic quality or complete accessibility conformance.

It includes versioned portable palette documents, backward-compatible imports, browser-local persistence, accessibility-aware analysis, and multiple developer-facing export formats.

Focus: color systems, accessibility, local-first applications, frontend product design, interoperability

A reproducible image and video glitch-processing workspace.

Effects are represented as deterministic recipes with explicit seeds and parameters. Source media and deliberate exports have persistent identity, video operations run through a bounded cancellable queue, and job state survives application restarts.

The goal is to make destructive-looking creative effects internally reproducible.

Focus: creative coding, deterministic media processing, FFmpeg, image processing, job recovery

An experimental research environment for exploring variation across many LLM responses as a semantic landscape.

It samples multiple completions, segments responses, builds blended feature representations, computes embeddings and neighborhood graphs, projects them through UMAP, clusters them, measures projection quality, stores provenance, and renders the result as an interactive 2D/3D visual environment.

The emphasis is not on pretending the visualization reveals an objective map of meaning, but on making a particular representation of model-output structure inspectable.

Focus: embeddings, dimensionality reduction, clustering, LLM research, visualization, reproducibility

Although these projects solve very different problems, many of them follow roughly the same pattern:

Source
  ↓
Evidence
  ↓
Durable identity
  ↓
Versioned transformation
  ↓
Derived interpretation
  ↓
Inspection / comparison

I am especially interested in systems where it matters that the result can be traced backward.

That can mean:

• which website observation produced a finding
• which historical source supports an interpretation
• which prompt and settings produced an image
• which feature space produced a semantic neighborhood
• which media source and deterministic recipe produced an export

I generally prefer explicit lineage over opaque automation.

Evidence and provenance If software makes a claim, I want to know what supports it.

Local-first tools Many of my applications are intentionally designed to work primarily on the user's own machine.

Durable workflows Jobs fail. Processes restart. Networks disappear. Users close tabs. Good systems should expect that.

Human-in-the-loop AI AI works best when the surrounding software provides strong context, constraints, inspectability, and deliberate decision points.

Web systems A lot of my work grows out of years spent thinking about websites as systems rather than collections of pages: infrastructure, content, performance, accessibility, SEO, rendering, analytics, and lifecycle.

Creative technology Some of the most interesting engineering problems come from tools that are useful primarily because they are strange.

Python        FastAPI       Flask
TypeScript    React         Vite
SQLAlchemy    SQLite        PostgreSQL
Playwright    Vitest        Pytest
FFmpeg        OpenCV        Pillow
OpenAI APIs   Embeddings    RAG
UMAP          HDBSCAN       FAISS / ANN
WordPress     PHP           MySQL

The specific stack matters less to me than choosing an architecture that makes the behavior understandable.

I work professionally around websites, web platforms, technical content, analytics, SEO, accessibility, performance, and WordPress.

Outside of work I build tools for subjects I find interesting: AI behavior, semantic spaces, visual media, website intelligence, color, historical symbolic systems, research workflows, and whatever other problem makes me think:

“There should probably be a tool for this.”

Most of the projects here started exactly that way.