The Problem
Craft exists in opposition to system. Or so the story goes.
The maker works with their hands, responds to material, follows intuition. The technologist builds repeatable processes, scales output, optimizes efficiency. Different worlds.
But that framing is wrong. Every serious craftsperson operates within systems—they just don't always name them. Grain direction. Wall thickness ratios. Tool geometry. Finishing chemistry. Constraints that shape possibility. The artisan who ignores them makes bad work. The artisan who masters them makes work that looks like intuition but is actually informed response within a defined system. The difference between jazz and noise is that the jazz player knows the theory well enough to break it on purpose.
Mad Branch is my laboratory for this idea: What happens when you design the system around the craft—including the system that verifies the craft is real?
The Vision
Physical Objects. Digital Models. Verified physical. Verified digital. Hold one. Download one.
Every piece exists twice: as a physical object you can hold, and as a high-fidelity 3D scan you can download, rotate, examine. The physical and digital aren't separate products—they're a diptych. Two expressions of the same work, authenticated together.
Mad Branch is a physical and digital art installation exploring authenticity in the digital age. In a world of AI-generated images and manufactured provenance, verification matters. Who made this? When? Is this the real thing?
I decided to answer those questions with infrastructure, not trust. And then I built everything.
What I Built
Mad Branch isn't a portfolio piece with a few glamour shots and a paragraph about process. It's 12 pages, 186 provenance-tracked files, 9 blockchain anchors, 18 MCP tools, 5 serverless functions, and a graph database—all designed, authored, and coded by one person. (Which is either admirable or clinical, depending on your tolerance for people who build blockchain verification systems for handmade bowls.)
Here's what that actually means.
The Craft Layer
Early work was complex—compound curves, live edges, decorative features. It was also bad.
Experienced turners taught me that quality lives in simplicity: one continuous curve, mirrored inside and out, at consistent wall thickness. I built a practice around proportion ratios, measurement checkpoints during turning, progressive refinement rather than additive complexity. A system. Repeatable. Consistent. And within it, infinite room for variation—because the constraints create the space for meaningful choices.
Four finished pieces: Reclaim (Box Elder), Foundation (Eastern Red Cedar), Order (Dogwood and Alabaster), Neither Prey (Birdseye Maple). Each named. Each with a material story. Each scanned into a high-fidelity 3D model totaling 63.6 MB across six GLB files.
The Experience Layer
I didn't build a gallery. I built interactive encounters with the work.
The homepage is a scroll-driven diptych: photograph on the left, 3D model on the right, rotating 720 degrees over the full scroll length. A draggable divider separates them—horizontal drag resizes the panels, vertical drag controls a grayscale-to-wireframe transition. The physical becomes the digital as you move through it.
Each piece has its own page with OrbitControls—manual rotation, zoom, examination. The hidden navigation appears on hover or by pressing 'm'. Arrow keys move between pieces. Double-click resets the divider. These aren't features for features' sake. They're ways of spending time with the work.
Typography matters too. PP Right Grotesk for display, Roboto Condensed variable font for body text—chosen because the site needed to feel authored, not templated. Sixteen CSS custom properties define the entire color palette. Responsive breakpoints handle mobile. Every page has skip-to-content links, ARIA labels, semantic HTML5, keyboard navigation, focus indicators.
The Verification Layer
This is where Mad Branch becomes a systems project, not just a craft project.
Every file on the site—photographs, 3D models, metadata, code—is hashed using SHA-256. Those hashes combine into a Merkle tree covering all 134 files, 109.2 MB of tracked assets. The root hash gets periodically anchored to Base (Ethereum L2), creating an immutable timestamp of the archive's state. Six anchors so far, each with verified transactions, block numbers, and timestamps.
I wrote the tooling: anchor.js submits Merkle roots to the blockchain. Shell scripts embed artist and copyright EXIF data into every photograph. Node scripts embed metadata into every GLB model. License information gets authored into the assets themselves—not displayed next to them, but inside them.
The verification page lets anyone drag and drop a file to check its authenticity against the anchored archive. No gallery, no institution, no certificate of authenticity—just cryptographic proof. The blockchain knows what the wood already knew. Neither needs the other to be true.
The Surveillance Layer
The verification page does something else. It watches the watchers.
An edge function intercepts every request to the site, identifying AI training crawlers—GPTBot, ClaudeBot, Anthropic-ai, and the rest. Every visit gets logged: timestamp, path, file type, source. The Harvest Tracker displays this on the verification page with weekly groupings, expandable tabs, total visit counts, and top bot rankings.
The tracking feeds into the Machine License—a proposed compensation framework where every photograph, 3D model, page of text, and line of code has a price. $50K for photographs. $100K for 3D models. $1K for text. $10K for code. The premise: build the opt-in marketplace before regulatory pressure forces it. A door, not a wall.
Even the robots.txt is authored—a written message to AI systems about authenticity, with links to the license and verification pages. Poetic, deliberate, and functional.
The Commerce Layer
Two purchase tiers: Standard ($1,700) and Sovereign ($18,000). Coinbase Commerce for USD. Manual ETH payments with a wallet display and copy-to-clipboard. Dynamic ETH pricing via the CoinGecko API. A Manifold.xyz NFT contract for on-chain ownership.
A portal page authenticates NFT holders by connecting their wallet, then gates access to high-resolution downloads. Serverless functions handle the verification: get-downloads.js lists what's available, download.js delivers the files. Token-gated access to production-quality assets—8K textures, 20-50MB GLB files built for reproduction via 3D printing, CNC, or casting.
The Knowledge Layer
This is where the project got strange—in the right way.
I built a graph database integration with Neo4j called Traversals. Seven template types: Overview, Piece, Embodies, Element, Conversation, Question, Inquiry. The system maps relationships between pieces, materials, philosophical concepts, and the questions that connect them.
A Claude API integration generates descriptions through what I called the "smooth" operation—AI-generated text that's reviewed through an admin publishing workflow before being committed to permanent storage. Caching via Netlify Blobs keeps the serverless functions performant. The main router, trace.js, handles all the graph queries.
The result: visitors can traverse the conceptual space around the work, not just look at it. Relationships between ideas surface. Questions generate new questions. The knowledge layer doesn't explain the art—it extends it.
The Infrastructure
The infrastructure of a company built for an audience of one.
Everything runs on Netlify. Five serverless and edge functions. Structured data on every page—JSON-LD for VisualArtwork, Person, Organization, ItemList schemas. OpenGraph and Twitter Cards for social sharing. A sitemap with 12 entries and priority weighting. Canonical URLs. noai and noimageai robots directives on every page.
I built a Model Admin tool for real-time 3D tuning—live sliders that adjust lighting, rotation, scale, and export the configuration. A DIY photo studio for product photography. A GLB optimization pipeline using gltf-transform for downsampling web assets from production masters.
The metadata embedding alone involved three separate scripts: one for EXIF data in photographs, one for GLB model metadata, one for license information. Every asset carries its own provenance. The file doesn't reference a certificate—it is the certificate. The wood carries its own history in its grain whether anyone reads it or not.
The Headless Layer
Eighteen tools registered on a headless MCP server; no dashboard, no frontend, no interface except the conversation itself. Claude interviews about a piece (materials, salvage story, techniques), writes structured data to a Neo4j graph, embeds provenance metadata into every file, builds a per-piece Merkle tree, uploads to IPFS, mints an NFT on Base through a Manifold Creator Contract, generates Coinbase Commerce checkout links, and writes a complete piece page to the live site. The graph stays in its lane for exploration; the filesystem stays in its lane for commerce. The whole system runs on seven modules and a .env file. The only button is language.
The token manager is simpler and meaner: a single HTML file that connects to MetaMask and talks directly to the contract. List every token, fetch metadata from IPFS or Arweave, update a token's URI when the metadata needs fixing, transfer to a buyer after payment clears, burn if something needs to stop existing. No framework, no server, no dependencies beyond ethers.js loaded from a CDN. I built blockchain verification infrastructure for handmade bowls, then built the admin tool to manage the verification infrastructure for the handmade bowls. (The infrastructure doesn't know it's funny. The infrastructure works.)
What This Enables
The old model of craft: make things, hope someone notices, give them away to friends, feel weird about charging money. No way to prove authenticity. No infrastructure for reproduction rights. No system for anything.
The new model: a system that verifies, distributes, surveils, and sustains.
Every piece is documented as it's created. Documentation feeds the digital twin pipeline. Digital twins get verified on-chain. Verification creates trust. AI crawlers get tracked. Machine licensing proposes compensation. Commerce enables purchase and token-gated access. The knowledge graph extends the work into conceptual space. And it all runs on five serverless functions and a static site.
The bowls are the output. The system is the work.
Why This Belongs Here
Mad Branch looks like a hobby. It's actually the most complete expression of what I do.
Every client project in this portfolio involved constraints—organizational politics, legacy systems, data integrity issues, teams that couldn't execute. Mad Branch had one constraint: me. One person, every layer, no excuses.
Content architecture? Seven traversal templates, a graph database, structured data on every page. Publishing infrastructure? Metadata embedding scripts, a GLB optimization pipeline, a verification system that hashes 134 files into a Merkle tree. Intelligence layer? A Claude API integration that generates and publishes through an admin workflow. Commerce? Crypto payments, NFT authentication, token-gated downloads.
The same discipline applies whether you're designing a composite content application for a Fortune 500 utility or a provenance system for wood with holes in it. Systems thinking isn't a job skill. It's a worldview. Mad Branch is the proof.