Twenty years of building

Got deep into Visual Basic and AppleScript as a teenager. Built hardcoded chatbots that pretended to be agents, including a fake "we're wiping your hard drive right now" routine that held a live conversation with whichever friend had walked away from their machine. Hand-rolled parsing, regex everywhere, decision trees by hand. Naïve NLP by any current standard, but I've been interested in agents that hold a conversation ever since.

Built my own enterprise simulation game, a car-company OS where you ran factories, managed budgets, modeled supply chains. Heavily inspired by Wall Street Raider, Capitalism 2, and Railroad Tycoon, which I was deep into at the time. Tracked state, time stepping, policy choice: that's still how I think about agentic worlds.

First proper research environment. Interned at the German Cancer Research Center (DKFZ) in Heidelberg, where I grew cell cultures, ran experiments, learned the equipment (PCR cyclers, gel electrophoresis, the rest of the molecular biology stack), and worked alongside the PhD students.

On the side I wrote a small inventory tracker app for the lab: reagents, samples, freezer slots, the usual entropy of a working bench.

A second Heidelberg lab project: an interactive expression-mining tool for BioQuant, with gene expression data overlaid on a taxonomic ontology (bacteria, if I remember right) and drill-down navigation through the tree to see what was differentially expressed at each level. Pre-d3, pre-Observable era, so the visualization was hand-rolled.

Online truck-booking platform built during an internship at Reds Road Express in Cape Town. Shippers list loads, available trucks accept. Same move as the lab tracker in Heidelberg: take a paper-and-phone process and make it a working web app. This time for industrial logistics.

Original screenshots are in old archives.

A year deep in the semantic web. Domain modeling, ontologies, OWL reasoning, enterprise architecture frameworks. Built a semantic modeling extension for OpenOffice Draw that turned freeform diagrams into typed RDF graphs. Defigner started in this period as a small JavaScript modeling playground.

A peer-to-peer marketplace built as a Facebook app, on top of their newly opened Platform APIs and social graph. Used the social graph itself as the trust layer for transactions. Facebook shipped Marketplace natively in 2016. Too early, too small.

Repo and screenshots are in old archives — adding details once I dig them up.

aws-lib, an extensible Node.js client for the AWS API. Started in September 2010 on Node 0.2, before Node 0.4 stabilized, before npm hit 1.0, and before the official aws-sdk for Node existed.

Concurrent CouchDB work: LivelyCouch, a CouchDB + Node.js fusion as an HTTP event-driven framework. CouchDB's revision-tree model is what later turned into Histo.

Plus small utilities, Node-Magick and spawn.js.

Pasteboard, peer-to-peer text sync between Mac, iPhone, and iPad over Bonjour on the local network. No internet, no server in the middle. Native apps on each platform. Co-built with Johannes Auer.

Sync between devices, with no cloud in the middle. Two years later I formalized it in the Histo thesis.

A year deep in language design and Erlang:

• Grammars — a parser generator written in Erlang. I was deep in OMeta, PEGs, and the wider "your own DSL in 200 lines" world.
• osm-routing — OpenStreetMap-based geo-routing, also Erlang.
• flights — interactive map of outgoing flights from US airports.

It continued into 2012 with eventlang and token-streams, parallel parsing experiments. The compiler and grammar work from this stretch is what later became autocompile.

Histo — the full thesis, readable here, also as a PDF and a source repo. A protocol for peer-to-peer data synchronization built around a Merkle DAG, three-way merge, semantic conflict resolution, and history tracking for offline-first apps. Inspired by git's data model.

I wrote the same idea three times before it worked. LivelyStore (Feb 2012) was a git-inspired content tracker as a C library, with LivelyC underneath it as an object system and object database. MoonStore was the Lua attempt later that year. Both got abandoned in favour of synclib in JavaScript, which is what the thesis is built on — at the time it was the only language that ran on every device I cared about.

The same primitive, content-addressed state with deterministic merge, now shows up in USD scene composition, agent commit chains, and CRDT systems like Automerge and Yjs.

The last paragraph of the thesis asks whether Histo could be used to roll out its own software updates, with nodes syncing new versions directly from each other. That question is roughly what Daslab's job runner answers now.

The thesis was the capstone of a year-long cluster. I built each piece of the data-sync stack from first principles as a small single-purpose library.

• Diff & merge — array-diff, array-merge (3-way), id-diff, id-merge, diff-merge-patch (sets/dicts/lists), longest-common-substring, range-merge, fuzzy-match, diff-utils, merge-utils
• Sync & storage — synclib, content-addressable, pluggable-store (unified KV interface), HistoDB (forkable browser-and-Node DB), histo-fs, histo-revisions
• Graphs — ancestor.js (LCA on DAGs), graph-difference.js (DAG diffing)
• Encoding — canonical-json (RFC 8785 deterministic JSON)

Three of these — ancestor.js, graph-difference.js, and canonical-json — still get pulled into stacks that need deterministic content-addressing.

A portable-runtime phase, starting around the time of the thesis. MoonStore (2012) was an early Lua-based sync library, the first try at the same idea in a small embeddable runtime. Then lua-experiments (C, Lua, mongoose web server, CMake), lua.cmake, luajit.cmake, and mongoose.cmake, building Lua and Lua-driven web servers as embeddable artifacts.

Making those builds clean meant going deep on CMake's internals. Out of that I wrote CMake by Example, the beginner-friendly intro I wished had existed. Still the top Google result for CMake guides.

Daslab's reactive SDK and its on-edge job runner come out of this stretch.

IoT and app work with Studio XO, the studio behind Lady Gaga's Volantis flying dress. Fibre optic LEDs in the garments, driven over Bluetooth Low Energy from embedded microcontrollers, animated by mood from an app we built. The pieces opened the VFILES runway show at New York Fashion Week, February 2016; Mashable shot it behind the scenes.

Zappy, screen capture and annotation for macOS. Zapier for Mobile, workflow automation from your phone, where I worked on the founding mobile efforts.

Four years close to the daily UX of non-technical knowledge workers: what they reach for, what trips them up, where automation actually lives in their day. A lot of the patterns I work with now trace back to what I saw at Zapier.

ShortcutAI started on the raw OpenAI completion API (GPT-3), before ChatGPT shipped. The first version was the simplest thing that worked: invoke a model from any text selection in Apple Notes.

It grew well beyond Apple Notes into a multi-channel AI assistant that worked across Telegram, Line, Facebook Messenger, and WhatsApp, with native macOS shortcuts, a Playwright-based browser-automation agent, a Spotlight-style command palette on the web, a marketplace, and a server runtime tying it all together.

The system was architected around what we'd now call Skills: typed agent commands with declared input schemas and a params → review → result flow per invocation. The 2023 Skill catalog included Scrape Website (URL → CSV), Summarize PDF, Transcribe Audio, Text-to-Speech, Text-to-Image, Image-to-Text, Image Maps (depth/segmentation), Resize Images, Obfuscate Video, Translate, Find Emoji / Find Illustration, and a "Create Custom Command" surface so users could ship their own Skills into the marketplace.

Architecture across multiple repos:

• shortcutai.swift — macOS system integrations: accessibility, global key events, focused-text-view fetching, custom key-sequence detection, streaming responses.
• shortcutai_agent — Playwright-based browser-automation agent over HTTP. Launch sessions, navigate, screenshot, scrape. An early take on what's now called computer use.
• shortcutai-modules — community-contributed Skills.
• Plus private repos for the server, API, docs, marketplace, and a Next.js web dashboard with a Spotlight-style command palette, the cross-platform surface for invoking Skills outside the macOS app.

Typed agent commands plus a marketplace and a dashboard later became canonical as ChatGPT plugins (Mar 2023), OpenAI GPTs (Nov 2023), and Anthropic Skills (2025).

Discotalk, a generative image and video iOS app, multi-model from day one (every major image/video model integrated), with a social layer for sharing prompts and remixing. Pre-Sora era.

What landed and what didn't shaped how I think about agent UX.

Daslab (private), a workspace where humans and agents collaborate via scenes. Content-addressed scene graph, USD-inspired layered composition, a trust layer that turns approve/reject signals into supervision, and a job runner that ships everywhere (Bun server, iOS, Rust/WASM core that targets browser, Mac, ESP32, iPhone). This is where all three questions above meet.

autocompile, Apache 2.0. Compiles observed agent workflows into deterministic programs via Answer Set Programming, with library learning (Stitch), rule discovery (ILASP), and per-slot neural policies. It sits in the process mining lineage with two extensions outside the field's mainstream: trust-layer signals as the supervision channel, and small policies filling each stochastic slot in the discovered structure.

Plus agent-otel and pii-proxy, covered above.