Loading
[..]LOADING INTERFACE
[..]PREPARING 3D SCENE
Making-of
Most of this site was written by AI coding agents. All of it was directed, reviewed, and repeatedly pruned by a human. This is a case study in what that collaboration actually looks like — including the parts where the AI was confidently wrong.
Avatar Window is a real product — a conversational 3D avatar, a procedural San Francisco that tracks live weather, recommendation engines that learn your taste. It’s also an experiment in method: nearly every feature was built by describing intent to an AI agent, letting it write the code, and then doing the genuinely hard part — deciding what to keep.
The lesson of the whole project fits in one sentence: AI makes generating software cheap, which makes judgment the expensive part. Everything below is about where that judgment gets applied.
~137k
lines of TypeScript
690
tests, 50 suites
~12,500+
lines of dead code deleted
65
custom React hooks
The third number is the one I’m proudest of. Deleting AI-generated code you shipped last month is the tax on generating it cheaply — pay it gladly.
The agents write components, refactor services, chase type errors, and draft copy. What they never own:
What the product is, what ships next, what “good” looks like. An agent will happily build four recommendation engines; deciding the site needs exactly one is a human call.
Nothing merges because the AI says it works. It merges when the type-checker, the linter at zero warnings, 690 tests, and a human reading the diff all agree.
The working ritual: describe the intent and constraints up front (the repo carries a long standing briefing document the agents read first), slice work into reviewable pieces — the YouTube integration landed as three deliberate slices: account linking, nightly sync, taste mapping — and review everything as if a very fast, very confident junior engineer wrote it. Because one did.
The failure mode of AI-generated software is rarely broken code. It’s plausiblecode — things that look finished and aren’t true. A sample of what review passes on this very site caught, kept here as a public exhibit:
None of these were caught by the AI that wrote them, and all of them were caught by adversarial review — sometimes by a second AI agent explicitly briefed to be a hostile reviewer, always with a human deciding what the findings meant. That’s discernment as a practice, not a vibe.
Type-check, lint with warnings-as-failures, full test suite, and a production build on every change. The machine holds the line so review attention goes to meaning, not mechanics.
Recurring adversarial sweeps over whole subsystems — search, recommendations, auth, the public site — hunting for dead features, dishonest UI states, and quiet drift between docs and code.
A standing rule the agents are briefed on: the UI never claims what the system doesn’t do. Provider outages get honest error states; empty features get removed, not hidden.
Dead code is a standing bug. Multiple purges — 5,000 lines here, 7,500 there — are recorded in the history like features, because they are.
Because this is what working fluently with AI actually is. Not prompting tricks — a division of labor: knowing what to hand the machine, describing it well enough to get something useful back, distrusting the output in precisely the right places, and owning whatever ships under your name.
The site you’re using is the demo. The method is the product. Even the avatar’s chat stack is deliberately model-agnostic — the provider is a config switch, because the point was never any one model. It was learning to work with all of them, on purpose.