How I design and ship with AI.

Claude design in, merged PR out.

At Surface Labs (YC), an AI-native GTM platform, I work as a contract design engineer: I design each page in Claude, then build and merge it myself in the production repo, with no handoff and never a self-merge.

Most core pages are live, the rest in review. Watch it happen: the design becomes the code becomes the merged PR.

Every decision is a fork. I lock one.

The AI does not wait to be told, and it does not run loose. For anything that matters it lays out a fork: real options, a recommendation, and the tradeoff between them. I lock one, sometimes against the recommendation, and it builds what I lock.

One rule sits above all of it. No production code until the mockup is approved.

One engine, every page on-brand.

Speed without a system produces off-brand pages, so I built the system first. Every new page starts as a small file of content, and a shared template turns it into the finished page, on-brand automatically.

A token check in CI blocks raw hex. Pages stay on the kit before they merge. The full artifact story lives in the Surface Labs case study.

Watch one typed object resolve into a finished, on-brand Surface page.

Green tests are not a working product.

Pulse and Ghost both taught me this. Pulse held 116 tests green and a clean typecheck while a compare panel contradicted the heatmap beside it. Ghost shipped headings rendered white on white, invisible, every test still passing. Tests assert that things exist; they cannot see that the pixels are wrong.

So I verify like a skeptic. The AI reviews its own work adversarially: reviewers raise findings, then separate refuters attack each one before it counts. On Pulse that loop confirmed 16 real bugs with 0 false positives, while 116 of 116 tests passed.

All green. Build clean. The readout still lies about the canvas beside it.

Six early merges out. Three reviewed PRs in.

Six merges once landed before they were cleared. I reverted all of them, then re-shipped the same work as consolidated, reviewed pull requests. The revert is the point: a healthy main branch matters more than my commit count.

On a live company repo, what you take back out matters as much as what you ship.

Memory is infrastructure, not notes.

A method only compounds if the AI remembers. Early on that meant one file read every session, around forty thousand tokens, mostly irrelevant to the task. I re-architected it: a small always-loaded core, topical rule files pulled only when the matching work starts, a failure checklist read only at review time.

Session-start cost dropped roughly sixty to eighty times, and each bug a review catches becomes one line, so the next session never re-debugs it. Same instinct as a design token: solve a thing once, encode the solution as infrastructure, then stop solving it.

One codebase renders every film.

At Surface Labs I built a Remotion video system, not a one-off render. Each film is one small data file, and the same timing logic places every bar and every sound cue, so swapping the data re-syncs both automatically (the films play silent here).

One codebase renders the same film square, vertical, and wide. I composed this on Surface tokens and synthesized the sound kit in code. No stock assets, no drift.

Watch one timing function drive the bars and the sound cues at once.

The method shipped four things you can open.

Surface Labs runs in production, Pulse and Ghost run live, and the fourth is the site you are reading. All four were built this way.