Some of the Things I've Built

I am a frontend-leaning fullstack engineer focused on developer tools, SDKs, frontend architecture, AI workflows and complex web products.

Here is a collection of some things I've built, more to come.

Read more about me.

Table of contents

Open source and browser projects

  • styled-jsx: Co-authored and was a main maintainer of the original CSS-in-JS solution included with Next.js.
  • SUIT CSS: Core maintainer of the component-based CSS methodology and tooling project used by teams including Twitter.
  • React Native for Web: Implemented onLayout and keyboard modality support.
  • Previeweet: Designed and built a Chrome extension that added inline media previews to Twitter before the product supported them directly in the feed. I reverse engineered Twitter's minified single-page application and integrated services including Instagram, YouTube, Flickr and Imgur. Source code
  • Refined Twitter Lite: Built a UserScript with UI improvements for Twitter Lite. I made its desktop layout single-column by adapting the responsive design mechanism used by React Native for Web. Source code
  • Other contributions: Next.js, Twitter's Flight.js, Webstudio, Babel plugins and more.

Yelp frontend and style guide

At Yelp I did major work on the public style guide and mentored new hires and interns.

I was the frontend engineer on rebuilds of:

  • business photo galleries on Yelp.com
  • user profiles
  • Yelp Talk, the community forum

Webstudio AI UI generation

In 2023 I built an early experiment in AI-driven UI generation and editing for Webstudio, an open source visual website builder.

Users could describe changes in natural language. The system translated those requests into validated operations that were applied to the editor tree. It could rewrite copy, edit styles, delete elements and generate new UI sections from a constrained set of components.

I built the standalone @webstudio-is/ai package around:

  • a provider-independent model interface with OpenAI adapters
  • task-specific AI workflows with Zod-validated structured inputs and outputs
  • typed operations separating model output from deterministic editor mutations
  • JSX conversion into Webstudio templates format
  • Tailwind class parsing and Heroicons conversion
  • image enrichment for generated image components
  • validation and filtering of generated components and properties

This was before reliable tool calling and structured outputs. I split planning and UI generation into separate model calls and added defensive parsing because a single prompt was not reliable enough for safe editor changes.

Rapidpages AI rendering pipeline

In 2024 I built another early AI UI experiment for Rapidpages: an experimental rendering pipeline for turning streamed AI output into interactive React interfaces.

The system used React Server Components as the core rendering layer. The flow was:

  • designer.rapidpages.com -> AI stream -> render to RSC -> stream to browser
  • third-party component libraries, including general purpose libraries like Shadcn, through Client Components
  • generated React and Tailwind UI rendered live in the browser

A key part of the project was the intuition that AI-generated software needed isolated execution environments. This was before sandboxed AI app builders became common and before tools like Bolt made it clear that sandboxed environments are crucial for this kind of app.

The prototype could generate working interfaces from prompts while keeping the rendering pipeline dynamic enough for live editing and reusable component libraries.

Demo

ghbrain

I built ghbrain to turn merged GitHub pull requests into structured datasets for coding models and agents.

It collects linked issues, commits, changes and review conversations. One transformation treats the PR author as the assistant and reviewers as users. The issue becomes the task, commits become implementation steps and review comments become feedback.

I also built an evaluation flow with two layers:

  • deterministic checks that validate the generated patch and expected files
  • model-based comparison against the accepted PR implementation for correctness and completeness

This made it possible to rank training examples and measure how generated changes differed from real engineering work.

PSPDFKit Web SDK and PDF Viewer

I worked on a complex browser-based PDF viewer and JavaScript SDK embedded in customer products. On a small senior web team of roughly two to six engineers I led a large share of feature design and implementation and shipped around 71 public SDK releases.

My work included:

  • the web experience and SDK API for real-time PDF comment collaboration
  • coordination with the C++ PDF engine, Elixir backend and design teams
  • a virtualized comments sidebar, virtualized document rendering, and other performance work
  • code splitting for server-backed and standalone WebAssembly installations
  • faster standalone loading
  • frontend architecture, SDK APIs design and implementation, documentation and customer integration support
  • related writing on CSS theming, accessible React modals and WebAssembly tooling

Virtualized comments sidebar demo

AMBOSS testing infrastructure

As a consultant I improved QA processes, CI and testing infrastructure used by an engineering organization of more than 70 people.

The project had around 280 Cypress end-to-end tests. Runs took more than 18 minutes and suffered from recurring flakiness. I introduced parallelism, adjusted resource allocation and moved suitable coverage into faster integration tests.

The result:

  • overall CI became roughly 40-50% faster
  • the Cypress suite dropped from more than 18 minutes to around 6-7 minutes
  • Cypress Dashboard gave the team visibility into failures and flakiness over time

GetDX embedding SDK

I built the earliest v0 of an embedding SDK for GetDX as an exploratory product. It tested how customers could integrate GetDX functionality into their own products.

The work focused on SDK boundaries and integration ergonomics for external engineering teams. GetDX, now DX, was later acquired by Atlassian.

Graduateland frontend platform

I rebuilt Graduateland's frontend architecture around reusable CSS, JavaScript and HTML components.

The shared platform supported the main product and 15 university-branded job portals without maintaining separate frontend implementations for each site.

Are you hiring?