The stack we ship on. Yes, we’d still pick it tomorrow.

TanStack Start since alpha. Supabase under five-plus apps. Tauri when the browser’s the wrong shape. Turso for local-first data. We don’t ship what the type system can’t catch.

The argument

End-to-end type safety.
The structural antidote to AI slop.

AI-generated code fails in structural ways — invented function names, wrong column references, hallucinated APIs. A type-safe stack catches that at compile time, before a human sees it.

Step 01

Schema

Postgres in Supabase is the source of truth. Tables, columns, constraints — all written once, in one place.

Step 02

Generated types

Types flow from the database through TanStack Start’s type-safe RPC layer. No hand-written DTOs. No drift between server and client.

Step 03

Compile-time enforcement

The frontend can’t reference a column or call a function that doesn’t exist. AI implementation gets the same compiler check we do.

Four layers.
One stance.

The bet

TanStack Start

Since alpha · 2 production apps

Type-safe RPC, router-first. We bet on it in alpha and shipped two revenue-earning apps before 1.0. Query, Form, and Table from the wider TanStack toolkit where they fit.

The bedrock

Supabase

5+ apps shipped

Postgres with RLS, real-time, auth, storage. Opinionated, proven, boring in the best sense. Five-plus apps shipped across our work and our own products. Row-level security is the part most teams skip and later regret; we lean on it from day one.

The escape hatch

Tauri

When the browser is the wrong shape

Filesystem access, OS integration, offline work. Tauri lets a web team ship native without picking up Rust as a specialty. Sample Vault is the proof: a real desktop app on a stack the same web team maintains.

The embedded option

Turso

Powers Sample Vault

Local-first SQLite at the edge of a Tauri app. Sample Vault uses it for fast, offline sample search across thousands of files. Right answer when the user’s data lives on their machine.

Read Turso’s case study

How we use AI

The stack is the discipline.
Everything else follows.

Without it, “AI-assisted” is just “vibe-coded” with better marketing.

Specification-driven.

We write the design before we write the code — AI or otherwise. The spec is the artifact we review and argue about. Implementation is downstream of judgment, and judgment is where the senior time goes.

The compiler is the first reviewer.

A type-safe stack means a whole class of slop fails before a human sees it. AI invents an RPC signature? Build breaks. The compiler reads every change before we do.

Aggressive human review on top.

Type safety catches structural slop, not logical slop. So every change is also read by a senior engineer before it ships. AI implementation doesn’t get a free pass — it raises the bar on review, not the speed of merging.

Stable interfaces, fluid implementations.

AI is good at writing implementations. It’s less good at picking the right interface to write against. Humans pick the seams — function signatures, data contracts — and AI fills them in. The boring parts at the edges become free; the interesting parts at the seams stay ours.

Tell us about
your domain.

Tell us what you’re building and what you know about your field that nobody else does. We read every message and usually reply within a day.