Ink Tide — Opus 5 shipped a cel-shaded boat racer from one prompt

Build me a cel-shaded arcade boat racing game in Three.js, running on an infinite open ocean, at a level of visual and mechanical quality that a AAA studio would ship. Not a demo, not a prototype — a finished, beautiful, playable game.

Non-negotiable constraints
Stack: Vite + Three.js (latest r1xx), TypeScript, ES modules. I must be able to run npm install then npm run dev and play it in the browser immediately. Nothing else. No frameworks I have to configure, no build steps I have to debug.
Zero external assets. No downloaded models, textures, HDRIs, or audio. Every mesh is built in code (procedural geometry / BufferGeometry), every texture is generated in-code (canvas 2D or noise in a shader), every sound is synthesized with the Web Audio API. If it isn't generated by your own code, it doesn't ship.
Target hardware: MacBook M5 Pro, Chrome. Lock a solid 60fps at retina resolution. Use instancing, frustum culling, adaptive pixel ratio, and a proper LOD scheme. Performance is a quality requirement, not an afterthought — a beautiful game that stutters is a failed game.
Art direction — this is the heart of the project

The entire game is NPR (non-photorealistic rendering), anime cel-shaded. Think Guilty Gear Xrd's ink work and Wave Race 64's stylized water energy, rendered with modern shader technique. Zero PBR realism. If any surface in the final game reads as "physically based," you have failed the art direction.

Implement, properly, all of the following:

Ramp / step lighting. Custom ShaderMaterial (or a heavily extended MeshToonMaterial) with a 3–4 band gradient ramp texture, NearestFilter, no interpolation. Quantized diffuse is the single most important part of the look — tune the band thresholds by eye, not by default values.
Inverted-hull outlines on boats, riders, buoys, and gates. Duplicate mesh, push vertices along smoothed normals, side: BackSide, black or deep-toned ink. Scale the push with view distance so line width stays constant in screen space — no fat lines up close, no vanishing lines far away.
Screen-space edge detection as a post pass for interior lines the hull trick can't produce. EffectComposer + a normal/depth prepass (MRT) + Sobel filter. Two line systems working together, tuned so they don't double up.
Fresnel rim light on every character and boat, so silhouettes pop against the water.
Banded specular. Hard-edged highlight shapes, no smooth falloff. Fake environment reflection with a matcap or ramp, never a real cubemap probe.
Sky and atmosphere: gradient sky dome shader, stylized cel clouds (flat shapes with hard rim edges, drifting), a sun with a bloom-ish stylized flare that stays graphic rather than photographic. Limited, high-saturation, deliberately chosen palette — pick one and commit to it across water, sky, hulls, and UI.
The water — treat this as its own AAA-sized problem

The ocean is the star of the game and most of the screen. Give it a dedicated sub-agent and more iterations than anything else.

Displacement: sum of 4–6 Gerstner waves in the vertex shader, with a low-frequency swell and higher-frequency chop layered on top. Real wave motion, real crest sharpening — not a sine ripple.
Infinite ocean: projected grid or tiled/recentred mesh that follows the camera so the player can drive forever with no visible seam, no visible tiling repetition, and no LOD popping.
Cel-shaded water color: banded by wave height and by depth, hard transitions between bands, no smooth gradient. Deep tone, mid tone, crest tone.
Stylized foam, done properly: hard-edged white foam that appears on wave crests above a threshold; a foam ring around every hull driven by a depth-difference mask; a persistent wake ribbon behind each boat that scrolls, spreads, and dissipates over time; spray particles on hard landings and hard turns. Foam is what sells stylized water — it should be a real system, not a decal.
Quantized sparkle highlights on the surface, animated, reading as anime light-glitter rather than specular noise.
The game

Format: 4 boats — me plus 3 AI opponents. 3 laps. Countdown start, finish line, results screen with times and placement.

Course: a closed circuit marked on open water by a glowing green racing line — a CatmullRomCurve3 spline rendered as a ribbon that sits on the water surface and rides the waves with it, so it rises and falls with the swell instead of clipping through. Plus floating checkpoint gates along the route, wrong-way detection, and a corner-preview indicator. Design an actual interesting circuit: fast straights, a hairpin, a wide sweeper, a chicane, one section that runs across the swell so the boats get airtime.

Boat handling: arcade, weighty, satisfying. Buoyancy sampled from real Gerstner wave height at 5–6 hull points so the boat genuinely pitches, rolls, and slams into troughs. Throttle, steering that tightens with speed, a drift/powerslide with a boost payoff, airtime off crests with a landing impact. It should feel like the boat is fighting water, not sliding on glass.

AI racers: spline-following with lookahead steering, per-racer personality (one aggressive, one clean, one erratic), mild rubber-banding so races stay close, collision avoidance between boats, and mistakes — they should occasionally take a bad line so beating them feels earned.

Riders: a cel-shaded character on every boat, and their animation matters as much as the boats. Rigged and animated in code: lean into turns, weight shift on acceleration and braking, arms working the throttle, crouch on landings, idle bob synced to the wave motion, a celebration on finishing. No T-posed statues, no rigid props. A stiff rider will sink the whole look.

Camera: spring-damped chase cam, FOV kick with speed, subtle screenshake on slams, a cinematic orbit during the countdown and on the results screen.

HUD: in the same cel style — speedometer, lap counter, position, split times, boost meter, minimap showing the spline and all four racers. Hand-designed, not default HTML.

Audio: synthesized engine tone that pitches with RPM, water rush that scales with speed, impact thuds, a start horn. All Web Audio, all in code.

How I want you to work
Fan out sub-agents. One owns the water shader system. One owns the cel-shading and outline pipeline. One owns boat physics and feel. One owns AI racers and race logic. One owns riders and character animation. One owns HUD, camera, and audio. One owns performance. Have them work in parallel against a shared architecture you define first.
Build a screenshot harness before anything else. Playwright, headless, capable of loading the game, driving it to a given moment, and capturing frames at retina resolution from several camera angles. Every visual claim gets verified against a real captured frame — never against your assumption about what the code does.
Run a dedicated visual critic sub-agent whose only job is to look at those screenshots and be harsh. Its standard: would this frame pass as a shipped, published cel-shaded racing game? It should name specific defects — banding thresholds that read as mush, outlines that break on silhouettes, foam that looks like static, a rider that reads as a prop, water that repeats. It reports defects; it does not approve work to be polite.
/loop each subsystem against its critic until the critic runs out of specific defects to name. Don't move on early, and don't declare something done because it "works" — working is the floor, not the goal.
Build in milestones, each one playable: (1) ocean + camera, (2) player boat with buoyancy and feel, (3) cel pipeline and outlines applied to everything, (4) course, laps, checkpoints, (5) AI racers, (6) riders and animation, (7) HUD and audio, (8) performance and polish pass. Show me something runnable at every milestone.
Track your own quality bar honestly. If a subsystem is at 70% of the target, say so and tell me why, rather than describing it as finished. I would rather hear that the foam needs another pass than find out myself.
Deliverable

A repo with a README, clean architecture, readable and commented shader code, and a working npm install && npm run dev. When I run it, I want to be dropped into a race that looks like a piece of published anime-styled game art, and want to play it again immediately after finishing.

Ultracode.