29:I[3619,["/_next/static/immutable/chunks/28ipaoqhmmg6q.js","/_next/static/immutable/chunks/40pouhsfxgbu3.js"],"default"] 2a:T49e, Traditional flight simulators restrict velocity changes to discrete steps or clock multipliers. In Artemis Velocity Vis, the simulator decouples velocity from the animation frame loop by treating canonical progress $p \in [0, 1]$ as the primary spatial coordinate. When scrubbing speed between $500\text{ mph}$ and $25,000\text{ mph}$, ground-track rates, Mach numbers, and remaining time estimations update with zero layout thrashing. ### 1. Aerospace Kinematics Equations * **Speed of Sound**: $c_0 = 767.26\text{ mph}$ ($343.0\text{ m/s}$) * **Mach Number**: $M = v_{\text{mph}} / 767.26$ * **Ground-Track Speed**: $v_{\text{mps}} = v_{\text{mph}} / 3600$ * **Frame-Rate-Independent Integration**: Given frame delta $\Delta t$ and multiplier $m$, spatial step $\Delta p$ is: $$\Delta p = \frac{\Delta t \cdot m \cdot v_{\text{mps}}}{D_{\text{geodesic}}}$$ ### 2. Catmull-Rom Skip Entry Altitude Modeling For high-energy lunar returns (Artemis II), the spacecraft executes an aerocapture **skip entry** dipping into the upper atmosphere to bleed kinetic energy ($210,000\text{ ft}$) before lofting back upward ($290,000\text{ ft}$) and initiating final parachute deployment. 2b:T66e, When flight paths and orbital ground tracks are rendered as straight lines on standard Web Mercator (EPSG:3857) maps, they deceive human perception. Web Mercator is conformal—preserving local angles at the expense of severe polar areal distortion ($\sec^2\phi \to \infty$). A straight line drawn between two coordinates on a Mercator map is a **Rhumb line (loxodrome)**, not the shortest distance on Earth. Spacecraft orbital trajectories follow great circles governed by the Riemannian 2-sphere metric $ds^2 = R^2(d\phi^2 + \cos^2\phi\,d\lambda^2)$. ### 1. Haversine Central Angular Distance & 3D Slerp Given origin $P_1(\phi_1, \lambda_1)$ and destination $P_2(\phi_2, \lambda_2)$, central angle $\Delta\sigma$ is calculated via: $$a = \sin^2\left(\frac{\Delta\phi}{2}\right) + \cos\phi_1 \cos\phi_2 \sin^2\left(\frac{\Delta\lambda}{2}\right), \quad \Delta\sigma = 2 \arcsin(\sqrt{a})$$ Intermediate surface waypoints at fraction $f \in [0, 1]$ are interpolated via 3D unit vectors $\mathbf{v}_1, \mathbf{v}_2 \in \mathbb{S}^2$: $$\mathbf{v}(f) = \frac{\sin((1 - f)\Delta\sigma)}{\sin\Delta\sigma}\mathbf{v}_1 + \frac{\sin(f\Delta\sigma)}{\sin\Delta\sigma}\mathbf{v}_2$$ ### 2. Empirical Divergence on the London → Tokyo Corridor On the sub-polar flight path from London (`51.51° N`) to Tokyo (`35.68° N`): | Metric | Great-Circle Geodesic | Flat Mercator Linear Chord | Distortion Delta | |---|---|---|---| | **Path Distance** | **5,939.48 miles** | **7,017.56 miles** | **+1,078.08 miles (+18.15%)** | | **Max North Latitude** | **68.99° N** (Arctic Siberia) | **51.51° N** (Kazakhstan) | **1,857 miles lateral separation** | 2c:T583, Great-circle paths represent the shortest distance between two points on a spherical surface. As a map morphs between 3D spherical and 2D planar topologies, these trajectories must warp dynamically without distortion or seam breaks. ### 1. Great-Circle Distance & SLERP Interpolation Given origin $P_1 = (\lambda_1, \phi_1)$ and destination $P_2 = (\lambda_2, \phi_2)$, unit surface vectors $\mathbf{v}_1, \mathbf{v}_2 \in \mathbb{S}^2$ are computed. Central angle $\Omega$ is obtained via the Haversine equation: $$h = \sin^2\left(\frac{\Delta\phi}{2}\right) + \cos\phi_1 \cos\phi_2 \sin^2\left(\frac{\Delta\lambda}{2}\right), \quad \Omega = 2 \arcsin(\min(1, \sqrt{h}))$$ For path parameter $u \in [0, 1]$ sampled across 64 waypoints, spherical linear interpolation (SLERP) generates intermediate surface unit vectors: $$\mathbf{v}(u) = \frac{\sin((1 - u)\Omega)}{\sin\Omega} \mathbf{v}_1 + \frac{\sin(u\Omega)}{\sin\Omega} \mathbf{v}_2$$ ### 2. Continuous Projection Morphing Each waypoint $(\lambda(u), \phi(u))$ is transformed through the continuous projection operator: $$\mathbf{p}_{\text{screen}}(u, t) = \mathcal{T}_t(\lambda(u), \phi(u); P)$$ On the 3D globe ($t < 0.5$), back-face culling is enforced using camera normal dot products ($\mathbf{v}(u) \cdot \mathbf{n}_{\text{camera}} > 0$). Trajectories are rendered with a phosphor glow halo and an animated photon particle with trail decay. 2d:T42b, Evaluating point-in-polygon raycasts across 180+ TopoJSON country boundaries during real-time continuous projection morphing causes heavy CPU bottlenecks and dropped frames. GeoGenesis replaces geometric hit-testing with an off-screen **24-bit bijective RGB color-picking buffer**. ### 1. 24-Bit Bijective Integer Encoding Each country feature index $k \in [0, N-1]$ is mapped to a unique 24-bit integer $C = k + 1$: $$R = C \pmod{256}, \quad G = \lfloor C / 256 \rfloor \pmod{256}, \quad B = \lfloor C / 65536 \rfloor \pmod{256}$$ Decoding the pixel value read under the cursor: $$\text{Index } k = R + G \cdot 256 + B \cdot 65536 - 1$$ If $R = G = B = 0$, the pointer is over ocean or void ($k = \text{null}$). ### 2. Zero-Stall Host Memory Pinning The off-screen canvas context is initialized with `{ willReadFrequently: true }`. This pins the backing buffer in host memory, eliminating GPU-to-CPU pipeline stalls during `ctx.getImageData()` calls. Pointer inspection executes in $< 0.05\text{ ms}$ ($O(1)$ constant time) regardless of polygon complexity. 2e:T671, GeoGenesis supports four cartographic projection topologies: **Orthographic** (3D disk), **Equirectangular** (Plate Carrée), **Winkel Tripel** (National Geographic standard), and **Mollweide** (equal-area ellipse). ### 1. Winkel Tripel: 4th-Order Taylor Series Sinc Guard Winkel Tripel is calculated as the arithmetic mean of the Equirectangular and Aitoff projections, with standard parallel $\phi_1 = \arccos(2/\pi) \approx 50.467^\circ$: $$\alpha = \arccos\left(\cos\phi \cos\frac{\lambda}{2}\right)$$ At the projection center ($\lambda \to 0, \phi \to 0 \implies \alpha \to 0$), direct evaluation of $\sin(\alpha)/\alpha$ causes floating-point division by zero. A 4th-order Taylor series expansion eliminates the singularity: $$\text{sinc}(\alpha) = \begin{cases} 1 - \frac{\alpha^2}{6} + \frac{\alpha^4}{120} & \text{if } |\alpha| < 10^{-6} \\ \frac{\sin\alpha}{\alpha} & \text{otherwise} \end{cases}$$ $$X_{\text{wintri}}(\lambda, \phi) = \frac{R}{2} \left[ \lambda \cdot \frac{2}{\pi} + \frac{2 \cos\phi \sin(\lambda / 2)}{\text{sinc}(\alpha)} \right], \quad Y_{\text{wintri}}(\lambda, \phi) = \frac{R}{2} \left[ \phi + \frac{\sin\phi}{\text{sinc}(\alpha)} \right]$$ ### 2. Mollweide Equal-Area: Newton-Raphson Kepler Solver The Mollweide projection requires solving the transcendental Kepler equation for parametric latitude $\theta$: $$2\theta + \sin(2\theta) = \pi \sin\phi$$ Using Newton-Raphson iteration seeded with $\theta_0 = \phi$: $$\theta_{n+1} = \theta_n - \frac{2\theta_n + \sin(2\theta_n) - \pi \sin\phi}{2 + 2\cos(2\theta_n)}$$ The solver terminates when $|\Delta\theta| < 10^{-11}$ (typically $\le 4$ iterations). 2f:T6b0, When transitioning between a 3D orthographic sphere and a planar cylindrical projection, standard GIS frameworks perform hard cuts or opacity fades. GeoGenesis implements a frame-by-frame continuous geometric morpher driven by the Pythagorean limb departure envelope $\sqrt{R^2 - y^2}$. ### 1. Parallel Limb Departure Derivation On an orthographic sphere of radius $R$, surface coordinates $(\lambda, \phi)$ map to Cartesian screen coordinates: $$x_{\text{ortho}}(\lambda, \phi) = R \cos\phi \sin\lambda, \quad y_{\text{ortho}}(\lambda, \phi) = R \sin\phi$$ At vertical offset $y \in [-R, R]$, latitude $\phi$ is fixed by $\sin\phi = y / R$. Applying the Pythagorean theorem to the cross-sectional circle parallel to the equatorial plane at height $y$: $$x_{\text{limb}}^2 + y^2 = R^2 \implies x_{\text{limb}}(y) = \pm \sqrt{R^2 - y^2} = \pm R \cos\phi$$ ### 2. Continuous Morphing Topology Function For unfurl parameter $t \in [0, 1]$ ($t = 0$: sphere; $t = 1$: planar projection $P$), the blended transformation $\mathcal{T}_t$ is defined as: $$\mathcal{T}_t(\lambda, \phi; P) = \begin{bmatrix} (1 - t) \cdot R \cos\phi \sin\lambda + t \cdot X_P(\lambda, \phi) \\ (1 - t) \cdot R \sin\phi + t \cdot Y_P(\lambda, \phi) \end{bmatrix}$$ ### 3. Dynamic Horizon Clipping $\alpha(t)$ At $t = 0$, only the visible hemisphere facing the camera is rendered ($\alpha_0 = 90^\circ = \pi/2\text{ rad}$). As $t \to 1$, the clipping boundary expands to reveal the complete $360^\circ$ planet: $$\alpha(t) = \frac{\pi}{2} (1 + t)$$ Antimeridian cutting (`d3.geoClipAntimeridian`) activates when $t > 0.001$, preventing meridian seam tearing during planar layouts while preserving continuous 3D rotation at $t = 0$. 30:T553, TerraGemini integrates a full WGS84 ellipsoid geodetic conversion engine with real-time screen-to-sphere raycasting and 3D target lock tracking. ### 1. Screen-to-Sphere Raycasting When the user clicks or hovers at screen coordinate $(x_s, y_s)$, the coordinate is unprojected into spherical unit space relative to center $(c_x, c_y)$ and scale $S$: $$r_x = \frac{x_s - c_x}{S}, \quad r_y = -\frac{y_s - c_y}{S}$$ If $r_x^2 + r_y^2 \le 1.0$, front-hemisphere depth $r_z = \sqrt{1.0 - (r_x^2 + r_y^2)}$ is computed and multiplied by the inverse camera rotation matrix $\mathbf{R}^{-1} = R_y(-\theta_y) R_x(-\theta_x)$ to extract geodetic latitude $\phi = \arcsin(p_y)$ and longitude $\lambda = \operatorname{atan2}(p_x, p_z)$. ### 2. WGS84 to MGRS (1-Meter Precision) The geodetic coordinates are processed through a UTM projection engine (calculating meridian arc distance $M$ and 5th-order series expansions) and mapped to the Military Grid Reference System (MGRS): - Derives the 6° UTM zone and 8° latitude band. - Identifies the 100,000m grid square using DoD/NGA row letter offset sets. - Produces 1-meter precision coordinates (e.g. `18T WL 83959 07350`). The locked target maintains dynamic 3D-to-2D screen tracking, rendering animated radar rings, occlusion culling on back-face rotation, and dynamic SVG leader lines anchored to the telemetry HUD. 31:T43f, To highlight continental boundaries and island archipelagos without adding heavy vector geometry, TerraGemini applies a discrete $3 \times 3$ Sobel convolution filter across the 4K raster landmass mask $I(x, y)$: $$G_x = \begin{bmatrix} -1 & 0 & +1 \\ -2 & 0 & +2 \\ -1 & 0 & +1 \end{bmatrix} * I(x, y), \quad G_y = \begin{bmatrix} -1 & -2 & -1 \\ 0 & 0 & 0 \\ +1 & +2 & +1 \end{bmatrix} * I(x, y)$$ The normalized edge magnitude is computed per vertex: $$S_{\text{edge}}(x, y) = \min\left(1.0, \frac{\sqrt{G_x(x, y)^2 + G_y(x, y)^2}}{4.0}\right)$$ ### Dynamic Shader Coastline Modulation In the vertex and fragment shaders, the uniform `u_edge_sensitivity` dynamically scales point size and brightness along coastlines: ```glsl float threshold = 1.0 - (u_edge_sensitivity * 0.85 + 0.08); float edgeFactor = smoothstep(threshold, 1.0, a_edge_strength); gl_PointSize = clamp(baseSize * fresnel * (1.0 + 1.6 * edgeFactor * u_edge_sensitivity), 1.0, 64.0); ``` This emphasizes continental boundaries while preserving smooth, anti-aliased transitions under high-speed globe rotation. 32:T617, TerraGemini renders oceanic reflection and planetary atmosphere using a raytraced billboard quad covering the screen-space bounding disc of the planet ($u^2 + v^2 \le 1.0$). ### 1. Spherical Normal Reconstruction For any fragment $(u, v) \in [-1, 1]^2$, fragments outside $r^2 = u^2 + v^2 \le 1.0$ are discarded. The unit normal $\mathbf{N}$ on the sphere surface is derived analytically: $$\mathbf{N} = \begin{pmatrix} u \\ -v \\ \sqrt{1.0 - r^2} \end{pmatrix}$$ ### 2. Solar Vector & Half-Angle Glint With solar azimuth $\theta_{\text{sun}}$ and constant solar elevation $\alpha = 0.35\text{ rad}$, the normalized light vector $\mathbf{L}$ is constructed. Blinn-Phong specular intensity is calculated using the half-angle vector $\mathbf{H} = \frac{\mathbf{L} + \mathbf{V}}{\|\mathbf{L} + \mathbf{V}\|}$ with an exponent of $s = 38.0$: $$I_{\text{spec}} = (\max(\mathbf{N} \cdot \mathbf{H}, 0.0))^{38} \cdot \text{step}(0.001, \mathbf{N} \cdot \mathbf{L})$$ The step function guarantees that the unlit hemisphere receives zero specular highlight. ### 3. Rayleigh Atmospheric Limb & Composite Limb scattering $I_{\text{limb}} = (1.0 - \sqrt{1.0 - r^2})^{2.6}$ produces an atmospheric rim halo. The final composited fragment combines diffuse ocean tone, specular glint, and atmospheric scattering in a single pass: $$\mathbf{C}_{\text{final}} = \mathbf{C}_{\text{ocean}} \cdot (0.18 + 0.82(\mathbf{N} \cdot \mathbf{L})) + \mathbf{C}_{\text{specular}} \cdot (1.85 \cdot I_{\text{spec}}) + \mathbf{C}_{\text{atmos}} \cdot (0.75 \cdot I_{\text{limb}})$$ 33:T4c1, In planetary particle visualizers, scaling point density dynamically usually incurs a heavy frame penalty — either through CPU-side vertex buffer re-allocations or repetitive `gl.bufferData` bus uploads. TerraGemini eliminates this overhead by pre-generating a maximum pool of 250,000 spherical surface points during the initial raster pass. Each point is importance-ranked (evaluating coastline distance and spatial dispersion) and packed into a single static interleaved vertex buffer (`[lon, lat, edge_strength, rank]`, 16 bytes per vertex) uploaded once at startup. When the user scrubs the point density slider: - No CPU memory is allocated. - Zero vertex bytes are transferred across the PCIe bus. - The WebGL draw loop executes an $O(1)$ range slice: ```typescript const renderPoints = Math.min(250000, Math.max(50000, Math.floor(targetDensity))); gl.drawArrays(gl.POINTS, 0, renderPoints); ``` Visual presets are managed identically: rather than recompiling shaders or modifying preprocessor `#ifdef` branches, uniform color vectors smoothly lerp toward target presets via exponential decay ($\alpha = 0.08$) on every frame. The result is instant, 60fps responsiveness across the entire density range. 34:T5c9, **Spent an entire day stress-testing the batch pipeline across multiple projects — verifying provenance claims, auditing conversation transcripts, and building the skill that would let me run `batch-project-pipeline` on *any* Antigravity project folder and get draft content out the other end.** The conversation hit 844 steps and 39 user turns, the longest single session in this project's history. The pipeline reads the conversation index, separates user conversations from subagent noise, deep-reads transcripts for inflection points, and drafts log entries in the site's voice. When the first dry-run produced 376 lines of speculative recommendations based on conversation *counts* instead of conversation *content*, I killed it and rewrote the skill to require evidence-backed provenance chains. Every log entry now cites specific conversation IDs and step ranges. Every thread traces back to its source entries. The skill went from 0 to 662 lines across 5 working days — a codified version of everything I learned about turning build history into portfolio content. Three skills now compose the full pipeline: `ai-studio-export-rescue` (342 lines) for cleaning raw exports, `batch-project-pipeline` (662 lines) for autonomous content production, and `publish-content` for the interactive human-in-the-loop workflow. The 55 apps aren't just sorted anymore — they're feedstock for a content machine that reads its own build transcripts and writes about what happened. 35:T4b9, **Tested the publish-content skill on this project and immediately realized: the agent writes like an agent, not like a person.** The skill could read transcripts, identify inflection points, and produce structurally correct MDX — but the voice was wrong. "In this session, we implemented the core pipeline" is how a bot talks. "55 AI Studio apps and no idea what to do with them" is how I talk. The fix wasn't a prompt tweak — it was a rule: read 3-5 existing log entries in `content/log/*.mdx` before drafting new ones. Match the voice. Bold declarative lead sentences. First person. Specific data. No "phase," no "implementation," no "session," no "execute." The /learn session after this conversation codified it: the batch-project-pipeline skill now requires voice calibration from existing entries before any drafting begins. The skill also got the cascading provenance format — conversations feed log entries, log entries build threads, threads compose projects. Every claim traced to a specific conversation ID and step range. The meta-lesson: automating content production is easy; automating content *quality* requires teaching the agent what good looks like by example, not by instruction. 36:T43f, **The snakes had heads, fangs, eyes, a forked tongue — and still didn't look like snakes.** First pass: individual spheres strung together. Hard to distinguish from the cabin environment, hard to tell they were even reptiles. Second pass: viper skulls, belly scutes, hood geometry, two-tone coloring. Better anatomy, but now they looked like a parts catalog — a head here, a body segment there, all floating in the same general area. The fix took a completely different approach: throw away all the individual meshes and rebuild each snake as a single continuous `CatmullRomCurve3` spline tube with procedural UV-mapped scale textures. Every vertebra follows the same smooth curve. The dorsal and ventral coloring wraps seamlessly around the tube cross-section. The tongue, fangs, and hood attach to the head control point, not as separate floating objects. 687 lines of `Snake.ts` to get a 3D reptile that actually slithers instead of jittering as a collection of disconnected geometry. Two rounds of "definitely an improvement, but..." before landing on the approach that worked. 37:T5c6, **Eighteen files compiled, the app appeared in my menu bar, and nothing worked.** The 🍅 icon was there. The popover opened. The timer showed 25:00. But clicking Start did nothing. Tapping the tab buttons — Timer, Break, Stats, Settings — nothing. The entire UI was a museum exhibit: look but don't touch. The issue: SwiftUI's default activation model inside an `NSPopover` doesn't make the popover the key window, so button targets never receive focus. The fix required explicit `NSApp.activate(ignoringOtherApps: true)` on popover show and rewiring the view hierarchy to use `@State`-driven tab switching instead of relying on implicit focus. Four minutes, three files rewritten, one rebuild — and the controls came alive. Then the user (me) reported tab label overflow: "Timer," "Break," "Stats," "Settings" crammed into a 330px popover was clipping text. Replaced text labels with SF Symbol icon pills — `timer`, `leaf.fill`, `chart.bar.fill`, `gearshape` — which fixed the width budget and looked better anyway. In the same pass, the timer's `DispatchSourceTimer` wasn't initializing on Start because the state machine expected a `ready` → `running` transition that the UI wasn't triggering. Wired the button directly to `TimerManager.start()` and the countdown began ticking. Total debug time from "nothing works" to "everything works": about six minutes. The 14-minute headline is real, but the honest story is 14 minutes to render + 6 minutes to respond. 38:T428, **The last batch of files rounded out the app — daily stats tracking, a sound system with 6 chime options, and the polish to make it feel native.** The `StatsView` tracks completed pomodoros, total focus time, snooze count, penalties incurred, and break tasks checked off, all persisted through `UserDefaults` via a `StorageService` singleton that resets at midnight. The sound system wraps `NSSound` with system chimes (Glass, Ping, Hero, Bottle, Submarine, Tink) and includes a live preview in the settings panel. Every user preference — focus duration, break lengths, snooze increment, penalty policy, sound selection, menu bar display mode — persists across launches. The app runs as a pure `LSUIElement` accessory: no Dock icon, no window chrome, just a menu bar popover with a tabbed interface (Timer, Break, Stats, Settings) navigated via SF Symbol icon pills. `make run` builds and launches it. Gemini 3.7 Flash wrote all of this unprompted — 18 files across Models, Services, and Views, with clean separation of concerns and zero compile errors. 39:T417, **The difference between a Pomodoro app you use once and one you keep running is accountability — so the model built a penalty engine.** Two free snoozes per session, no judgment. Hit snooze a third time and consequences escalate: a random physical challenge (20 squats, 15 push-ups, 45-second plank, 30 jumping jacks, 1-minute wall sit, or 25 high knees), a 50% break time tax, or a hard lockout that disables the snooze button entirely. There's a `maximumDiscipline` mode that applies all three. The penalty state tracks snooze count, manages challenge assignment via `PenaltyChallenge.randomChallenge()`, and resets cleanly between sessions. The menu bar icon swaps from 🍅 to ⚠️ when a penalty is active — a small visual shame signal that's surprisingly effective. Alongside this, the model generated 8 curated break micro-tasks across 7 categories — hydration, stretching, 20-20-20 eye relief, box breathing, desk tidying — each with specific instructions and time estimates. The break task system supports custom entries too. 3a:T625, **The page.tsx grew to 1,058 lines — two custom GLSL shaders, a procedural starfield, foreground cloud wisps, atmosphere gradients, and a Shoreline reveal — and the starfield was *still* pixelated at certain scroll positions.** Chose procedural starfield over PNG (Option A — guaranteed crisp at any viewport size). The cloud breathing drift turned out nice — each PNG layer drifts laterally at a different speed via UV displacement, so if you linger at any numeral, the clouds slowly shift past each other. "Kind of cool" was the exact reaction, and that's honest: it's one of those effects you only notice if you stop scrolling. The shader stack by the end: `CloudMaterial` handles luminance-based alpha with UV drift and scroll-driven warm tint. `AtmosphereMaterial` transitions from `#0a0612` night through deep purple to warm gold across three scroll phases — cruise, dive, reveal. Bloom at luminance threshold 0.15 with 1.2 intensity for the god-ray glow. Camera controller interpolates position, rotation, and FOV based on scroll phase, with the tilt steepening after 45% to sell the nose-dive. The Shoreline reveal drops a camera-tracked Y-positioned image that fades through cloud parting. Three commits. Ten days. Seven conversations that kept crashing from image-dimension 400 errors. Pushed the last commit at 11:48 PM. The gap between the vision in my head and what renders in the browser never fully closed — but the gap got smaller with every scroll audit session, and the shader architecture for chasing it is all there in those 1,058 lines. 3b:T451, **The hardest part of building a scroll-driven 3D experience with an AI agent isn't the code — it's the feedback loop.** I'm looking at clouds that feel pixelated at 30% scroll, a numeral that sits on top of the scene instead of feeling embedded in it, and a starfield that's blown out. But how do I communicate "the 9 should feel like some wisps go in front of it, some behind it, and some through the center" to an agent that can't see what I see? We tried a workflow: the agent scrolls to key percentages, takes screenshots, I describe what's wrong at each one. It almost worked — until the agent crashed. Tried again. Crashed again. Four screenshots of issues, voice-transcribed feedback about cloud drift speeds and number dissolve timing, artifact comments about dive-bomber camera angles. Sixteen user turns in one session just trying to close the gap between what I imagined and what the renderer showed. The vision is still there — the full layered PNG + shader + particle version that the Next.js codebase was reaching for — but the shipped Vite version is the one that actually works. 3c:T582, **Invented a new way to give design feedback to an AI: walk through every 10% of the scroll, screenshot it, describe what's broken.** The problem was communication. I could see the issues — the numbers floating on top of everything, the amber haze with no motivated light source, the clouds that didn't part to reveal anything — but saying "it doesn't feel right" gets you generic fixes. So I asked the agent to scroll to each position, take a screenshot, and wait for my response. At 50% scroll, the "5" was just sitting on top of everything instead of integrated into the scene. At 40%, the issue crystallized: "we're scrolling vertically, not what I'd describe as forward then taking a dive down through the clouds as the clouds then start to part." I reached for a metaphor — "imagine a dive bomber cruising through clouds, as they approach the target the dive happens, the pilot pushes forward on the yoke, and they begin to nose-dive towards the target." That landed. The agent drafted a visual audit document tracking issues per scroll segment and an implementation plan: foreground cloud wisps layered *between* the camera and numerals for depth occlusion, scroll-driven god rays with asymmetric falloff, and a cloud-parting sequence where the layers spread apart to reveal Shoreline below. Sixteen user turns in a single session — the most interactive conversation across the whole project. 3d:T592, **I kept describing a cinematic dive through clouds and the agent kept building a vertical slideshow with fog.** The disconnect was frustrating because I could *see* it — the 9 dissipates into cloud layers as the camera tracks down, the background image starts to shine through, the light diffusion through the volumetric clouds picks up the colors from the sky. Golden hour warmth leaking through particle haze. But what rendered was a countdown number pasted on top of fading layers. Not *in* the clouds. *On* the clouds. Two sessions crashed out from network errors, each time losing context about the artistic direction. By session four, I/O had already happened, so the framing shifted — this wasn't a hype countdown anymore, it was a retrospective celebration. "Register Now" got cut. "I was on Cloud Nine" became the tagline. That reframe actually made it better: there's something more honest about building something for an event that already happened. You're not selling tickets. You're preserving a feeling. The technical gap persisted though. The agent understood the code — it was generating valid Three.js, correct shader uniforms, working scroll interpolation. What it couldn't bridge was the difference between *layers changing opacity* and *a camera moving through a space*. That's a perception problem, not a code problem. And it's the one that would take three more sessions to even name properly. 3e:T48e, **Built a drag-and-drop portfolio triage dashboard in a single session because spreadsheets weren't cutting it.** The manifests gave me structured data, but staring at JSON didn't help me *decide* anything. So the agent spun up an Express server on port 3333 serving a visual triage UI — project cards with screenshots, drag-to-bucket sorting, group labels, and persistent state saved to `triage-state.json`. I dragged 12 projects into "get out of my sight" (duplicates, raw exports I'd never touch), grouped related apps by theme (all the weather apps into AtmoStudio, all the globes into GeoGenesis, 6 I/O countdowns into one cluster), and wrote notes explaining *why* each grouping existed. The triage state tells the real story: 55 projects collapsed into 12 logical groups with human-written rationale. The "weather studio" cluster has 4 apps. The "countdown" cluster has 6. The "particles and physics" group has 3. Each note is a decision — "find what I love about each and bring those into a globe studio" or "these are ways to play with particles, maybe a game." A manifest gets you structured data. A triage dashboard gets you structured *decisions*. 3f:T45f, **Came back to the physics timer 11 days after recon, said "get this running and ship it," and the whole rescue — boot to GitHub push — took 26 minutes.** Stripped 6 dead dependencies (`@google/genai`, `express`, `dotenv`, `autoprefixer`, `tsx`, `@types/express`), fixed a silently broken shimmer animation that was missing its `@keyframes` declaration, cleaned every AI Studio scaffold artifact (cleanup log, audit report, default title, HMR disabling hack). Added an SVG favicon, captured 3 screenshots and a 4.3 MB demo GIF via Chrome DevTools MCP, wrote a README that leads with the demo and explains the I/O countdown context. Package count dropped to 159 clean dependencies, zero `npm audit` vulnerabilities, zero console errors. The app itself turned out to be genuinely fun — the four physics modes (Core, Fluid, Cosmic, Thermal) each completely transform the particle behavior, and the explosive transitions between countdown digits have real visual impact. The cursor creates a vortex effect and the glassmorphic HUD panels push particles out of their way when you drag them. One commit, pushed clean. 40:T481, **Shipped TerraGemini to GitHub as a clean standalone repo, but not before learning the hard way why you never trust scaffold artifacts over raw source code.** The rescue started with a facepalm — an early plan assumed the app was an image uploader because stale audit notes from export time described a different build before anyone read `RotatingEarth.tsx`. Once grounded in reality, we stripped the AI Studio scaffolding, added `@types/d3-geo` and `@types/topojson-client` alongside an `env.d.ts` reference so `npx tsc --noEmit` passed clean, and migrated inline styles to Tailwind CSS 3. The architectural fix was in `services/gemini.ts`: replacing eager SDK initialization with a lazy `getAI()` guard that verifies `VITE_GEMINI_API_KEY` on demand, allowing the 3D globe to boot and spin freely with zero credentials. Because headless Chromium renders blank dark rectangles on WebGL canvases, we spun up a GPU-backed DevTools runner to capture Mount Fuji's AI intelligence card, styled satellite wireframe, and a 36-frame 10fps demo GIF (1.7MB). Shipped in two commits with a 1.28-second Vite production build and zero npm audit vulnerabilities. 41:T424, **Shipped ais-will-it-fit to GitHub and then realized the real output wasn't the app — it was the process.** E2E verification passed on the first try: uploaded a desk lamp and a bedroom photo, Gemini returned "Verdict: Yes" with dimensional analysis ("18-24 inches in height... ample room on the floating nightstands"). Demo GIF captured — 16 frames, 602KB, the full upload → analyze → verdict flow. But when I asked why the existing AI Studio rescue workflow wasn't followed as a structured skill, the answer was honest: the knowledge was all in AGENTS.md as prose rules (dead dep audit, favicon check, Tailwind content globs, visual verification), but nobody had ever formalized it into an invokable skill. The references to `ai-studio-export-rescue` and `/project-launch-workflow` in the rules were forward references to things that didn't exist yet. So this project became the catalyst — the successful ship that got crystallized into the `ai-studio-export-rescue` skill so every future AI Studio export follows the same pipeline automatically. 42:T455, **Dropped into another AI Studio export — a codebase called "Will It Fit?" — and for once the concept sold me before the code did.** Upload a photo of your couch, upload a photo of your doorway, and Gemini 2.5 Flash tells you if you're about to ruin your Saturday. The recon found the usual scaffold wounds: a broken SVG namespace (`www.w.org` instead of `www.w3.org`), `animate-fade-in` used in 6 places but never defined anywhere, no favicon, dead DNA/audit files from the export pipeline. But underneath all of that — 793 lines of clean TypeScript, proper structured JSON output from the Gemini API with a schema-enforced verdict enum (`Yes`, `Tight`, `No`), and an Imagen 4.0 integration that generates photorealistic objects on a white background when you don't have a photo handy. Five preset quick-picks: sofa, armchair, bicycle, refrigerator, fiddle leaf fig. The actual spatial reasoning prompt is clever — it tells Gemini to use door knobs and light switches as scale references and consider diagonal tilting. Fixed all five bugs, killed seven dead files, shipped to GitHub in one session. 43:T4c1, **Came back to the I/O tracker at 1 AM to finish the rescue — fix the repo, get real screenshots, make it not look like a scaffold.** The plan was straightforward: update the Gemini model to stable `gemini-2.5-flash`, capture screenshots with dummy data fallback, clean up the README. Then the user said "don't be boring, and don't use purple," and the scope tripled. Redesigned everything with dark glassmorphism — `backdrop-filter: blur(20px)`, `rgba(255,255,255,0.04)` surfaces, teal/blue/coral/amber palette, staggered card entrance animations, shimmer skeleton loading states. Deleted the dead `constants.ts`, fixed Tailwind content globs that were scanning `node_modules` (CSS dropped from 40KB to 16KB), created a proper `.env.example`. Captured 56 Playwright frames at 2× Retina and assembled a 2.4MB demo GIF. Everything looked great locally. Then the user came back 11 hours later and the GitHub repo still showed the old broken screenshots. The problem? Never committed and pushed. All 14 modified files sat as unstaged local changes. The single most embarrassing failure mode: it works on my machine, but I never shipped it. Fixed it, pushed it, and wrote a `/learn` rule so it never happens again. 44:T471, **Fixed the dashboard, captured fresh screenshots, and they were pictures of my own IDE.** The rescue was supposed to be straightforward: add the missing `gemma4:26b` color (`#FFD090`, warm orange), strip the dead `@google/genai` dependency, delete the scaffold files, swap the grid from 3 columns to 4, and recapture. All of that worked. Then `screencapture` on macOS grabbed the entire display — Antigravity IDE sitting right on top of Chrome — and committed those as the "fixed" screenshots. The user saw it immediately: "yikes see the screenshot!" Switched to Playwright headless Chromium, which renders the page in its own browser instance and doesn't care what's on your desktop. Clean captures. Then `npm audit` flagged postcss and sharp vulnerabilities bundled inside Next.js 15. First override attempt: `EOVERRIDE` error because postcss was both a direct dependency and an override target. The fix is the `"$postcss"` reference syntax — tells npm to use the direct dep's version everywhere. Zero vulnerabilities after. From runtime-error-as-hero-image to clean repo in 26 minutes. Six commits. Three screenshot do-overs. 45:T459, **Opened the repo and the committed screenshot was a Runtime Error.** Not a subtle one — `Cannot find module './331.js'`, full stack trace, red background, the works. That was the `initial-state.png` in `screenshots/`. The demo GIF was 98KB of the same crash. This is the image that represented the project on GitHub. Someone (me) had exported a Gemma 4 benchmark dashboard from AI Studio, pushed it, and never actually checked if the screenshot showed a working app. The recon turned up more: `@google/genai` listed as a dependency but never imported anywhere — the app uses zero AI APIs, it's 44 hardcoded benchmark data points in a Next.js API route. A `use-mobile.ts` hook scaffolded but never called. A sysinfo endpoint that nothing hits. And the real bug hiding under the surface: four Gemma 4 models in the data (`e2b`, `e4b`, `26b`, `31b`) but only three had colors in `MODEL_COLORS`. The 26B was rendering invisible bars. 367 lines of actual code, and the neo-brutalist design with Recharts scatter plots and Motion animations genuinely worked. The app was fine. The presentation was a crime scene. 46:T4de, **The number "11" was reading as "1 1".** `gap-16 md:gap-24` — four to six rems between the pillars. Two separate capsules floating on a dark background, not two digits of the same number. Tightened to `gap-6 md:gap-10` and the composition snapped into focus. But the gap was one of seven things wrong. The pillars had no feet. A numeral "1" has a serif beak at the top (we had that) and a horizontal foot at the bottom (we didn't). Added a glowing base bar at the bottom of each pillar — gradient-fading at the edges, brightening on hover. Now it reads as a serif "1" instead of a thermometer. Killed the `pl-8 md:pl-12` centering hack that was pushing everything right. Staggered the entrance: pillars rise first (0.1s, 0.25s), then heading (0.6s), subtitle (1.0s), timer (1.3s) — cinematic cascade instead of everything appearing at once. Elevated the SVG accent paths from 2 invisible wisps to 4 animated dashed paths in Google's brand colors with staggered delays. Made the plasma breathe — opacity oscillating 30→50% instead of sitting flat at 40%. Seven changes, one pass. The user's response: "well done, let's do all of them." Sometimes the best iteration is a single dense sweep after you've actually looked at the thing. 47:T518, **Opened an AI Studio export and it ran on the first try.** 309 packages, zero errors, dev server up in 521ms. The app is two glowing capsule pillars filled with scrolling code forming the number "11" — a countdown to Google I/O 2026 with spring-physics cursor trails and a cycling plasma background. Visually striking out of the box. Dead simple under the hood: 329 lines in a single React component, no API keys, no backend, no state management. Just animation. The surgery was cosmetic. Stripped `express`, `@google/genai`, `dotenv`, `lucide-react` — all template residue, never imported. 309 packages became 157. Typed the `any` prop. Froze the timer at `11:00:00:00` since the event already happened — this is Day 11's build, the timer says Day 11. Swapped the generic subtitle for `// the code was counting too`. Then I asked what else needed work and looked at the actual browser. The heading said "11 Days" in italic serif — and the serif was Times New Roman. We loaded Inter for the body but never loaded a display serif. The most prominent text on the page was using a system fallback nobody chose. Everything after that fix — Playfair Display, the pillar gap, the entrance animations — traces back to actually looking at what the browser rendered instead of what the code said. 48:T41f, **The entire globe lives in a single 1,053-line React component running a `requestAnimationFrame` canvas loop — no Three.js, no WebGL.** GlobeViz.tsx hand-rolls a D3 `geoProjection` that interpolates between orthographic (sphere) and equirectangular (flat map) using a parameter `t` from 0 to 1. The projection factory computes per-vertex: `x = (1-t) * cosPhi * sinLambda + t * lambda`, `y = (1-t) * sinPhi + t * phi` — a linear blend between Cartesian sphere coordinates and raw lat/lon. Clip angle widens from 90° to 180° as the globe unfolds. Country hit-testing uses a hidden off-screen canvas where each country renders in a unique RGB color from its ISO 3166-1 numeric code — pixel read at mouse position maps directly to country. On top of that: 300 twinkling parallax stars, procedural flight/shipping/data connections animated along great-circle arcs via D3's `geoInterpolate`, click ripples expanding from coordinates, oscillator-based Web Audio SFX, CRT scanline overlay, corner-bracket HUD, and live telemetry readout. All Canvas 2D. 49:T4de, **Built the full 10→0 countdown with morphing transitions and color evolution — and the digits were unreadable.** Particles scattered into vague blobs within seconds of forming. The spring force (0.05) was too weak to hold shape against the noise displacement (amplitude 0.14 per frame). Transition explosions with scatter forces up to 35 launched particles off-screen, and the soft springs couldn't pull them back fast enough to reconverge before the next number. The finale stuttered — particles oscillated around origin instead of settling cleanly, and the CSS fade overlapped with the convergence, creating a jarring flash. Rewrote the physics from scratch. Thinned the strokes from `0.35 * S` to `0.18 * S` so particles actually trace digit shapes. Tripled the spring stiffness from 0.05 to 0.12 so particles hold formation. Dropped noise amplitude from 0.14 to the 0.008–0.033 range — breathing, not jittering. Killed the scatter/reconverge transition entirely and replaced it with direct smoothstep morphing between digit shapes. Shallow z-depth (0.15 instead of 0.5) keeps the 2D digit readable from the camera. 560 lines of single-file TypeScript, all per-frame CPU physics. Shipped the same night — two commits at 2:17 AM. 4a:T4f3, **Exported a particle countdown from AI Studio and it stopped at nine.** Literally — the app generates 10,000 instanced spheres that form "10" with spring physics, you click "Next," they explode and reconverge into "9," and then… nothing. Next button disabled. Dead end. The "AI" text input that says "alter the physics" is three `if/else` statements matching hardcoded strings. No Gemini API is ever called. Six unused dependencies in `package.json`, including the Gemini SDK that never gets imported. Classic AI Studio export: visually impressive for 30 seconds, then you've seen everything. Ran a full recon — the particle physics engine is genuinely solid. 10,000 instanced spheres with per-frame spring forces, Perlin-ish noise displacement, friction damping, and mouse repulsion. Bloom post-processing from `@react-three/postprocessing` makes it glow. The foundation is worth building on. So I ran a `/grill-me` and locked in the design: strip the fake AI, strip the overlay, extend the countdown 10→0, add a convergence finale where everything collapses to a single bright point, add an evolving color palette from cool indigo to white-hot amber, add a slow camera drift, and let the whole thing run itself. No UI. No chrome. Just particles and time. 4b:T498, **Told the model: swing for the fences on humor, but the punchline is the simplicity.** The form stays boring — gray-50, corporate, looks like you've filled it out 400 times. The button develops a personality arc across four escalating tiers of 33 dodge messages. First two hovers, it scoots politely: "Not today." By hover four, it's dramatic: "My therapist said I don't have to do this." By seven, existential crisis: "We both know they're not going to read it." Past ten, fully unhinged: "I've filed a restraining order." Spring physics panic alongside — stiffness climbs from 300 to 900, damping drops from 20 to 6, and the button starts physically shrinking at high dodge counts like it's trying to hide. Viewport-aware bounds keep it from clipping off-screen. `onPointerEnter` replaced `onMouseEnter` so touch and pen get dodged too. `onFocus` fires a dodge and immediately blurs so keyboard tabbing is equally futile. The secret exit is Ctrl+Enter — and the reward is deliberately anticlimactic: "Thank you for your inquiry. A member of our team will reach out within 7–10 business days. Just kidding. Nobody works here." Still one component. Still 214 lines. 4c:T47d, **First boot threw a black screen and a fatal reconciler crash, but one dependency bump brought 1,541 lines of custom shaders to life with live Gemini weather grounding.** The crash was `Cannot read properties of undefined (reading 'ReactCurrentOwner')` — React 19 removed the internal that `@react-three/fiber@8.15.16` depended on through `react-reconciler@0.27.0`. Bumping R3F to `^9.7.0` and `@react-three/drei` to `^10.7.7` while ditching orphaned `three-stdlib` instantly cleared the console and booted the Three.js canvas. Feeding a live API key into `geminiService.ts` activated Gemini 2.5 Flash with `{ googleMaps: {} }` tool grounding. Searching "Reykjavik" returned 10°C cloudy night conditions and dynamically re-parameterized the scene: `uNight` flipped the procedural building shader to illuminate windows, FBM noise carved volumetric clouds drifting across the sphere, and snow particle shaders faded out smoothly at the glass boundary. Verified the live Google Maps attribution chips in the UI, patched the dead API key banner in `VeoStudio.tsx`, and captured the hero state across 10 source files without a single runtime error. 4d:T46e, **Halfway through the rescue, the agent got sidetracked into thinking DeepWeather was an image generator — I had to pull it back.** The AI Studio export came with three Gemini-powered tabs: the 3D weather globe (the actual app), a Veo 3.1 video studio, and an Imagen 4.0 prompt box. The agent latched onto the Imagen tab as if that *was* the product. It's not. It's a generic text-to-image input that has nothing to do with procedural weather visualization — just a corollary that got exported alongside the real feature. Ripped out `ImagenStudio.tsx`, its enum value, its service function, and its orphaned screenshot. The nav went from three tabs to two: Globe and Veo. The demo GIF capture also hit a wall — the Chrome DevTools MCP kept dropping the connection when interacting with WebGL pages, so the final recording used macOS `screencapture -v` as a fallback and got cropped/converted with ffmpeg. The GIF shows the default globe rotating but not a full city-search-and-transform cycle, because that required sustained browser interaction the MCP couldn't maintain. Shipped to GitHub as-is — the live app is the demo. 4e:T58c, **Exported an I/O countdown from AI Studio and the first thing that hit me was the scroll.** Not the code quality (standard AI Studio scaffold — importmap block, CDN Tailwind, wrong API key wiring). The scroll. You start at 9 and descend through parallax cloud layers toward a reveal. The bones were there, but the flesh was clip art. Generic cloud PNGs. No volumetric feel. No light diffusion. No sense that you're actually *in* the sky. The vision was specific: you're on Cloud 9 — as in, on cloud 9 with excitement for I/O — and as you scroll, the numeral 9 dissipates into the cloud layers while the camera tracks down through them. AI-generated cloud textures with luminance-based alpha so white areas become transparent. Three layers — back, mid, front — each drifting at different speeds via UV displacement in a custom GLSL shader. The agent generated the cloud PNGs directly through the image model after the regular image generation endpoint kept throwing 400 errors on oversized base64 payloads. Four AI cloud assets, a Shoreline Amphitheatre background, and a procedural starfield later, the sky existed. React Three Fiber, drei's `useTexture`, custom `shaderMaterial` for each cloud plane, `smoothstep` edge feathering to kill the hard borders. 492 lines in page.tsx for the first commit. Getting the raw materials was the easy part — making them feel like atmosphere was going to be the war. 4f:T459, **The most impactful fix was literally one line of JSX: ``.** The component existed — 7 lines of perfectly written React using Leaflet's `useMap` hook to pan the camera — it just wasn't rendered inside ``. One missing child element, and the entire core experience was broken. The geodesic fix was more satisfying: replaced linear lat/lon interpolation with proper spherical intermediate point math — same Haversine-family trig, no external dependencies, ~15 lines. Added a `geodesicArc()` helper that samples 100 points along the great-circle so the dashed route line actually curves correctly on the map. Then the fun part: ripping out every trace of Gemini. Deleted `@google/genai`, `firebase-tools`, `.env.example`, `metadata.json`, the AI Studio audit report. Cleaned `next.config.ts` of the `DISABLE_HMR` webpack hack. Wrote a real README with screenshots, init'd a repo, pushed to GitHub. 659 packages pruned. Zero vulnerabilities remaining. The app was always a pure client-side visualization — it just took three conversations to get it there. 50:T41c, **The Gemini integration isn't scaffolded — it's the whole point.** You type a weather description, hit Generate, and a `responseMimeType: "application/json"` call to Gemini 2.5 Flash returns a typed `WeatherConfig` object: 15 fields covering gradient colors, cloud density and speed, rain/snow intensity, wind angle, sun position and scale, condition label, and temperature. Every slider and color picker in the sidebar snaps to the new values. The schema uses `@google/genai`'s `Type` enum to constrain each field (numbers get ranges, colors get hex descriptions), and the result merges with `DEFAULT_CONFIG` so missing fields don't break anything. Rate-limit handling is real too — exponential backoff with 3 retries on 429s. The interesting pattern here is using Gemini's structured output as a configuration engine rather than a chat interface: natural language in, typed parameters out, no parsing step. "Cyberpunk acid rain in Tokyo" becomes a specific gradient, a specific cloud density, a specific rain intensity — all in one API call. 51:T40c, **Ran the full project-launch-workflow on Atmosphere and it shipped in a single conversation — recon, cleanup, screenshots, README, git push.** The app had already survived two prior passes: a recon session that mapped every file and confirmed the architecture was solid, then a boot-and-evaluate session that got it running and confirmed zero console errors. The launch pass stripped the AI Studio scaffolding (DNA_FIX_LOG.md, metadata.json, audit_report.md), renamed the package from `ai-studio-applet`, fixed the `index.html` title, created an SVG favicon, and wrote a README with tech stack table, architecture diagram, and quick start. Captured three screenshots (feed view, design studio, scrolled feed) plus a demo GIF via Chrome DevTools MCP. The honest assessment: this is one of the strongest AI Studio exports in the gallery. A shared-Canvas R3F architecture, custom shaders, a layer inspector that explodes cards into CSS 3D space, and an AI feature that's functional but gracefully optional. One commit, one push, done. 52:T4fc, **Launched 67 DNA scanner subagents in 5 waves across all 55 AIS projects — then followed up with 50 DNA executor subagents to apply fixes.** The scanner wave pattern was simple: send 12-15 projects per wave, let the manifests flood in, launch the next wave before the previous one finishes. Each scanner reads `package.json`, checks git remotes, counts screenshots, detects framework versions, and writes a structured `.ais-manifest.json` into the project root. 52 of 55 projects got manifests. The executors then ran the initial cleanup playbook on each: delete import maps, migrate API keys from `process.env` to `import.meta.env`, swap Tailwind CDN scripts for npm-installed PostCSS pipelines, and clean scaffold cruft. The whole operation ran autonomously from a single parent conversation — 6,006 total steps across scanners and executors combined, one human message at the end asking for a recommended prompt for the next phase. The `ai-studio-export-rescue` skill (342 lines) codified every fix pattern learned from doing these rescues manually, and the agent applied it at fleet scale. The result: 52 projects with structured manifests, consistent build pipelines, and a clear status classification — `shipped`, `needs-polish`, `raw-export`, or `local-only`. 53:T43d, **Opened up an AI Studio export called TerraGemini expecting a generic Three.js wrapper and found a 918-line hand-rolled WebGL renderer instead.** The entire globe runs on custom GLSL shaders without a single Three.js dependency — separate vertex and fragment programs for dot-matrix land masses, graticule lines, a pulsing location beacon, and a background star field. It pulls 50m TopoJSON data from CDN, rasterizes it onto an offscreen 4096×2048 2D canvas, and runs cosine rejection sampling across the pixel data to generate ~150,000 holographic points with uniform sphere density. There is a built-in momentum physics engine for drag rotation, spring dampening on zoom, and smooth RGB lerping between day mode and amber night mode. The reconnaissance turned up the standard AI Studio detritus — a dead import map pointing to `aistudiocdn.com`, a missing `index.css`, and a Vite `define` block baking `PLACEHOLDER_API_KEY` straight into the 556KB production bundle. But the core rendering math was pristine, compiling clean across 160 npm packages with zero vulnerabilities. 54:T4e1, **Dropped into a dark room — an AI Studio export called "Spatial Understanding for SUV Modifications" — and found something genuinely useful hiding under the scaffold.** Upload a photo of your van's empty cargo area, and Gemini 2.5 Flash traces every edge: floor outline, wheel wells, trim contours. It returns measurements in inches and a closed `floor_outline` path that Three.js extrudes into a 3D preview you can orbit. The system prompt is a full-page fabrication brief — it tells the model to think like a van builder, not a vision demo. The catch: it's a raw export. `@react-three/fiber` 8.x ships with React 19, which means `--legacy-peer-deps` to install. The example van images point to a GCS bucket that returns 404. The `src/` directory has diverged copies of `atoms.tsx` and `consts.tsx` — the root versions are the live ones, but the originals had different default images (stock objects like pumpkins and clocks instead of van interiors). The JSON parsing is blind `JSON.parse()` with no fallback — if Gemini returns markdown-wrapped JSON (which it does about 30% of the time), the app crashes. 24 source files, 2,839 lines, zero git history. Status: raw-export, needs the standard cleanup pass before it's gallery-ready. 55:T4d2, **Cracked open another AI Studio export expecting the usual hollow scaffold — found a 3D weather snow globe with 4 custom GLSL shaders, FBM terrain generation, and Google Maps grounding actually wired up.** Mapped 10 source files across a Vite + React 19 + Three.js stack: `WeatherSystem.tsx` (432 lines) holds snow, rain, and volumetric cloud particle systems all driven by hand-written vertex/fragment shaders with sphere-containment fading and FBM noise carving. `IsometricCity.tsx` (391 lines) does procedural terrain with 4 terrain types (island, coastal, mountain, inland), rejection-sampled tree placement, and tiered buildings with a custom shader that lights up windows at night using per-cell pseudo-random functions. The `geminiService.ts` calls Gemini 2.5 Flash with `{ googleMaps: {} }` tool config to pull real-time weather for any city — temperature, condition, terrain type, building style — and extracts grounding metadata chunks for source attribution links in the UI. Three Gemini API features total: grounded weather, Imagen 4.0 image generation, and Veo 3.1 video generation. Hallucinated package versions in the original export needed fixing, but the architecture was real — not scaffolded, not hollow. 56:T413, **Dropped into a dark room — a BuckyBounce AI export straight from Google AI Studio — and found 60 physics bodies bouncing correctly but leaking AudioContexts on every collision.** Found a Vite + React + Three.js codebase with a working Hoberman breathing sphere, gravity gun, shatter/reform mechanics, and FM-synthesized impact audio. The core physics loop was solid: damped Hooke's law springs ($F = -k \Delta x - c v$) with elastic boundary collisions. But every node collision spawned a fresh `AudioContext` instead of reusing a shared one — 6,598 console errors in a 3-minute session. A geometry rotation TS error broke the initial render path. Both were 15-minute fixes once diagnosed: lazy-init a single `AudioContext`, cast the rotation properly. The initial cleanup — import map removal, Tailwind CDN→npm migration, API key migration to `import.meta.env` — had already run. Two hours of recon, two surgical fixes, and the export went from "crashes with a wall of red" to "60-body spring-mass sim running clean at 60fps." 57:T43b, **Dropped into another AI Studio export expecting the usual hollow scaffold. Found a 442-line custom GLSL cloud shader instead.** The app — a 3D weather dashboard called "Atmosphere" — renders 9 weather cards in a masonry grid, each with its own volumetric cloud layer running through a shared React Three Fiber Canvas via `View.Port`. Not separate Canvases per card (which would tank performance) — one global Canvas with drei's `View` component routing each card's 3D scene into its own DOM container. The cloud shader uses 2D simplex noise with turbulence, scrolling UV offsets, and coverage/density/sharpness uniforms. There's a full Design Studio mode with real-time parameter editing, 2D canvas precipitation effects (rain, snow), lunar phase calculations from actual synodic month math, and a Gemini API integration for AI-generated themed locations. 2,358 lines of TypeScript across 10 source files. Built it to boot, fixed the missing `index.css` and a Tailwind CDN reference, and the whole thing rendered first try. No console errors. Production build passed clean. 58:T446, **Dropped into an AI Studio export blind — no docs, no brief, just a zip file and full autonomy to figure out what this thing is.** Turned out to be a spacecraft speed visualizer: Artemis II re-entry at 24,500 mph mapped onto familiar geography. NYC to SF in six minutes. The concept is visceral and immediate — you don't need an explanation. Under the hood: Next.js 15, React 19, Leaflet with CARTO light tiles, and a `requestAnimationFrame` animation loop with delta-time physics. Six source files, ~400 lines of real code, zero backend. The e-ink aesthetic — black-on-white, thick borders, monospace numerals — looks like a mission control readout printed on paper. Found three bugs before touching anything: `MapUpdater` defined but never rendered (camera frozen), linear lat/lon interpolation instead of great-circle (London→Tokyo goes through the earth), and five dead dependencies including `@google/genai` that was never imported. The app has zero AI in it. Also found 31 npm audit vulnerabilities, all from `firebase-tools` — a dev dependency that serves no purpose here. 59:T455, **Opened the Antigravity sidebar and counted 55 folders starting with `ais-`.** Every one is an AI Studio export — some are weather globes, some are countdowns, some are bill parsers, some are Three.js particle toys. Most still had the default `ai-studio-applet` package name and a README that said "Run and deploy." I'd worked on a bunch of them but couldn't tell you which ones had GitHub repos, which ones built, or which ones were duplicates of each other. The question wasn't "what did I build?" — it was "how do I even start sorting 55 experiments into something manageable?" Started by asking the agent to grill me on organizational strategy. The options were environment-level grouping, one mega-project, or individual project folders. Settled on individual folders because each app has its own `package.json` and build pipeline — trying to umbrella them would have been fighting the tooling. Then the real insight: before doing *anything* to the apps, build a manifest system so every future operation has structured data to work with instead of parsing `package.json` heuristics every time. 5a:T577, **Jetski Bridge v10 doesn't talk to Gemini. It talks to the Antigravity Language Server — the same internal service the IDE uses — by reverse-engineering its protocol from process tables.** `ps aux | grep language_server_macos_arm` to find running instances. Extract `--extension_server_port` and `--csrf_token` from the command line args. Probe port offsets +1 through +10, hitting `/Heartbeat` with the CSRF token until one returns 200. That's the Language Server port. From there, the bridge becomes a full gRPC-Web proxy: `StartCascade` to create conversations, `SendUserCascadeMessage` to dispatch prompts with model selection and planning mode config, `GetCascadeTrajectory` to poll for responses. The chat page (v7 of the UI, generated as an inline HTML template at 270 lines of embedded JavaScript) renders a live trajectory viewer with Follow mode — polling every 1.5 seconds, content fingerprinting to detect when streaming responses fill in, re-rendering only new steps. 40 functions, 1,199 lines of Node.js, zero dependencies beyond `http`, `fs`, `path`, `os`, `crypto`. A workspace discovery server on port 9101, per-workspace proxy servers on 9102–9110, model selection across 9 models including Claude 4 Opus Thinking. The Chrome extension talks to the bridge, the bridge talks to the IDE, and suddenly you can control your entire development environment from a browser tab. 5b:T44c, **Spent an evening sending 56 messages through the bridge trying to get the AI to do one thing: change a file and show me the result.** The tools were there — `read_file`, `write_file`, `edit_file`, `run_command`, `reload_page`, `get_browser_page`, `fetch_url`. Eight tools, all wired up. The AI could create `test.html` with a blue background. It could change it to red, purple, green. It could tell me what page I was looking at. What it couldn't do: chain "edit the file" with "reload the page." Every time I said "change the background and reload," it did one or the other. "I cannot directly open files in your browser" — 14 times. The `monitor-bridge.js` fallback used the Gemini API directly with function calling, and the function definitions were textbook. But function calling without execution chaining is just a suggestion engine. The moment that landed: when I said "navigate to localhost:3000/test.html" and it actually did it — not because it understood the chain, but because I gave it an explicit enough instruction. That's the gap. Not tool availability. Tool orchestration. 20:[["$","$L7",null,{}],["$","main",null,{"id":"main-content","className":"flex-1 focus:outline-none","tabIndex":-1,"children":[["$","section",null,{"className":"max-w-3xl mx-auto px-6 pt-16 pb-12 md:pt-24 md:pb-16","children":["$","div",null,{"className":"animate-in-up","children":[["$","span",null,{"className":"inline-block text-xs font-mono text-accent bg-accent-muted px-2 py-0.5 rounded mb-4","children":"Daily feed"}],["$","h1",null,{"className":"text-foreground text-3xl md:text-5xl mb-4","children":"Builder's Log"}],["$","p",null,{"className":"text-muted text-lg md:text-xl max-w-2xl leading-relaxed","children":"Daily discoveries, shipped features, and honest debugging notes."}]]}]}],["$","$22",null,{"fallback":["$","div",null,{"className":"h-32 flex items-center justify-center text-muted","children":"Loading log..."}],"children":["$","$L29",null,{"days":[{"day":"2026-08-31","entries":[{"slug":"high-contrast-e-ink-and-mission-control-cartography","title":"High-contrast E-Ink, NASA Mission Control Dark, and radar telemetry design","date":"2026-08-31T18:30:00.000Z","tags":["Design","Visualization","Canvas"],"thread":"artemis-velocity-vis","body":"\nMission control telemetry interfaces require instant legibility, high data density, and clear visual hierarchy under varied lighting environments.\n\nArtemis Velocity Vis implements 3 distinct cartographic themes powered by client-side GPU tile filters:\n\n### 1. GPU Tile Layer Filter Pipelines\n* **E-Ink Terminal**: Converts color OpenStreetMap tiles into electronic paper:\n `filter: grayscale(100%) contrast(140%) brightness(102%);`\n* **NASA Mission Control Dark**: Deep obsidian base with radar cyan and amber alert accents:\n `filter: brightness(95%) contrast(110%);`\n* **Satellite Reconnaissance**: Calibrated ESRI imagery for maximum polyline contrast.\n\n### 2. Hardware-Accelerated Radar Beacon\nThe spacecraft marker projects a pulsating radar ping ring powered by pure CSS keyframe animations:\n\n```css\n@keyframes radar-ping {\n 0% { transform: scale(0.8); opacity: 0.9; }\n 70% { transform: scale(2.4); opacity: 0.0; }\n 100% { transform: scale(2.4); opacity: 0.0; }\n}\n```\n"},{"slug":"leaflet-camera-tracking-ssr-isolation-and-coordinate-sync","title":"Leaflet camera tracking, SSR isolation, and coordinate heading synchronization","date":"2026-08-31T18:20:00.000Z","tags":["React","Performance","Visualization"],"thread":"artemis-velocity-vis","body":"\nLeaflet accesses global browser APIs (`window`, `document`) directly during module evaluation. Importing Leaflet into Next.js React Server Components triggers runtime `ReferenceError: window is not defined` exceptions and hydration mismatches.\n\n### 1. Zero-Side-Effect Drop-In Isolation\n`` encapsulates Leaflet via client-only dynamic loading with a theme-aware skeleton fallback:\n\n```tsx\nconst MapComponent = dynamic(() => import('./Map'), {\n ssr: false,\n loading: () => \n});\n```\n\n### 2. Spherical Heading Alignment\nInstantaneous spacecraft heading $\\theta$ is derived from lookahead vector $\\mathbf{P}(p + \\epsilon)$:\n\n$$\\theta = \\operatorname{atan2}(\\sin\\Delta\\lambda \\cos\\phi_2, \\, \\cos\\phi_1 \\sin\\phi_2 - \\sin\\phi_1 \\cos\\phi_2 \\cos\\Delta\\lambda)$$\n\nThe bearing angle is applied directly to the `L.divIcon` DOM element via CSS `transform: rotate(${heading}deg)` to keep the nosecone aligned to the flight trajectory in real time.\n"},{"slug":"real-time-ground-track-speed-and-mach-telemetry","title":"Real-time ground track speed, velocity scrubber, and Mach number telemetry","date":"2026-08-31T18:10:00.000Z","tags":["Visualization","Animation","Math"],"thread":"artemis-velocity-vis","body":"$2a"},{"slug":"geodesic-haversine-spherical-arc-vs-mercator-chord","title":"Geodesic Haversine spherical arc derivation vs flat Mercator linear chord error","date":"2026-08-31T18:00:00.000Z","tags":["Visualization","d3-geo","Algorithms"],"thread":"artemis-velocity-vis","body":"$2b"},{"slug":"haversine-slerp-geodesic-flight-arcs","title":"Geodesic arc morphing: spherical SLERP flight paths across dynamic projections","date":"2026-08-31T12:30:00.000Z","tags":["Visualization","d3-geo","Animation"],"thread":"geogenesis-unfolding-globe","body":"$2c"},{"slug":"24bit-bijective-rgb-picking-buffer","title":"Hardware-accelerated country picking: 24-bit bijective RGB buffers","date":"2026-08-31T12:20:00.000Z","tags":["Visualization","Canvas","Design"],"thread":"geogenesis-unfolding-globe","body":"$2d"},{"slug":"multi-projection-mutators-sinc-kepler","title":"Multi-projection topology mutators: Taylor sinc guards and Newton-Raphson Kepler solvers","date":"2026-08-31T12:10:00.000Z","tags":["Visualization","d3-geo","Projection"],"thread":"geogenesis-unfolding-globe","body":"$2e"},{"slug":"pythagorean-limb-departure-unfurl-engine","title":"Continuous unfurl engine: Pythagorean limb departure and dynamic horizon clipping","date":"2026-08-31T12:00:00.000Z","tags":["Visualization","d3-geo","Projection"],"thread":"geogenesis-unfolding-globe","body":"$2f"},{"slug":"mgrs-utm-geodetic-telemetry-reticle","title":"MGRS/UTM geodetic conversion and 3D screen-to-sphere raycasting","date":"2026-08-31T08:30:00.000Z","tags":["React","TypeScript","Visualization"],"thread":"terragemini-build","body":"$30"},{"slug":"3x3-sobel-normal-convolution-coastlines","title":"3x3 Sobel normal gradient convolution for procedural coastlines","date":"2026-08-31T08:25:00.000Z","tags":["Shaders","WebGL","Visualization"],"thread":"terragemini-build","body":"$31"},{"slug":"blinn-phong-specular-ocean-glint-solar-vector","title":"Blinn-Phong specular ocean glint and raytraced atmospheric scattering","date":"2026-08-31T08:20:00.000Z","tags":["Shaders","WebGL","Visualization"],"thread":"terragemini-build","body":"$32"},{"slug":"o1-gpu-vertex-slicing-250k-points","title":"O(1) GPU vertex slicing: 250,000 points without PCIe memory reallocation","date":"2026-08-31T08:15:00.000Z","tags":["WebGL","Shaders","Performance","Visualization"],"thread":"terragemini-build","body":"$33"}]},{"day":"2026-08-26","entries":[{"slug":"48-threads-got-screenshots-and-the-homepage-got-a-layout","title":"48 threads got screenshots and the homepage got a real layout","date":"2026-08-26T09:04:00.000Z","tags":["Design","Infrastructure"],"thread":"building-the-site-thread","body":"\n**Ran a portfolio-wide media capture across all 48 threads and 8 projects, then redesigned the homepage featured section from scratch.** The old featured layout was a flat list. The new one uses a 1+2 hero grid — one large card with the primary project image, two smaller cards flanking it, then the rest below. Added a 5th featured item (Personal Pomodoro) and swapped MUJŌ's hero image for one that actually shows the ink physics. Promoted Building the Site itself from a thread to a project, which felt appropriately meta. By end of day: every thread had at least one image, every project had a hero capture, and the homepage looked like it was designed instead of generated. Twenty-two commits in 18 hours.\n"}]},{"day":"2026-08-25","entries":[{"slug":"135-entries-in-one-commit-and-the-site-has-mass","title":"135 log entries in one commit and the site finally has mass","date":"2026-08-25T21:14:00.000Z","tags":["Infrastructure","Automation"],"thread":"building-the-site-thread","body":"\n**Pushed 135 log entries and 35 threads to the site in a single session — the batch pipeline's first real production run.** The site went from a handful of manually written entries to a living archive overnight. Each entry was mined from git history and Antigravity conversations, backdated to real build timestamps, and tagged with the canonical vocabulary. Then 18 more gap-fill entries and a QC review pass. The thread count jumped from 13 to 48. The log page went from something you'd scroll through in 10 seconds to something with actual depth. The build still passed with zero errors, which meant the content validation script was doing its job — every `thread:` reference resolved, every tag was canonical, every MDX file parsed clean. Five months of build history, compressed into one evening of pipeline output.\n"}]},{"day":"2026-08-24","entries":[{"slug":"from-55-folders-to-a-content-machine-that-runs-itself","title":"From 55 folders to a content machine that runs itself","date":"2026-08-24T12:19:00.000Z","tags":["AI Studio","Automation","Infrastructure"],"thread":"building-the-site-thread","body":"$34"}]},{"day":"2026-08-23","entries":[{"slug":"twenty-six-files-and-zero-git-history","title":"Twenty-six files, a full test suite, and zero git history","date":"2026-08-23T18:03:00.000Z","tags":["Swift","Apple Silicon","Git"],"thread":"personal-pomodoro-build","body":"\n**Realized today that Personal Pomodoro — 26 files, 2,295 lines of Swift, and a full test suite — had been built, debugged, and documented without a single git commit.** The project directory had everything: 18 source files across Models, Services, and Views, unit tests, a Makefile, build scripts, and an Info.plist — but `git status` returned `fatal: not a git repository`. Switched to Claude Opus 4.6 (Thinking) to handle the housekeeping. Wrote a `.gitignore` to keep `.build/`, `.swiftpm/`, and `DerivedData` out of the tree, updated the clone URL in `README.md`, and packaged 2,416 insertions across all 26 files into commit `d5a5038`. One `gh repo create` command pushed the whole thing public to GitHub on `main` — complete with the penalty engine, break micro-tasks, and dockless menu bar controller.\n"},{"slug":"teaching-an-agent-to-write-like-me-not-like-an-agent","title":"Teaching an agent to write like me, not like an agent","date":"2026-08-23T17:36:00.000Z","tags":["AI Studio","Automation"],"thread":"building-the-site-thread","body":"$35"},{"slug":"content-pipeline-overhaul","title":"Content pipeline overhaul: the site now builds itself from atoms","date":"2026-08-23T15:06:00.000Z","tags":["Infrastructure","Automation","Design"],"thread":"building-the-site-thread","body":"\n**Rebuilt the content architecture from the ground up — log entries are now the only thing I write, and everything else composes from them.** Thread pages render entries in expandable accordions. Project pages show a \"How This Got Built\" provenance section. The same MDX renders identically whether you're reading a standalone log entry, expanding it inside a thread timeline, or seeing it in a project's build history.\n\nAlong the way, fixed three production bugs that had been hiding: tables and headings had zero CSS styling site-wide, the ScoreBadge component showed \"NaN%\" on the Gemma 4 page because MDX doesn't pass numeric JSX props correctly, and the Edge Lab log entry was parented to the wrong thread. Cleaned up the content relationships, documented the atomic model, and built the publishing skill that generated this very entry.\n"}]},{"day":"2026-08-22","entries":[{"slug":"pruning-the-demogod-for-open-source-release","title":"Pruning the demogod for open source release","date":"2026-08-22T18:45:00.000Z","tags":["Vite","Cleanup","Shipping","Open Source"],"thread":"hair-raising-demogod-build","body":"\n**Before pushing the project to GitHub, I stripped out every trace of boilerplate and dead weight.** Deleted 184 lines of unused `App.css`, scrapped boilerplate Vite SVGs, and pruned stale dependencies down to a clean 3,788 lines of TypeScript and CSS across 16 files. Configured `.oxlintrc.json` to catch lint regressions without slowing down iteration. The production Vite build now transforms 1,818 modules and bundles the complete client app in just 183ms. Pushed the repository to `ais-hair-raising-demogod` on GitHub with complete documentation, animated demo GIFs, and studio state screenshots. A goofy creative coding experiment is great, but a goofy creative coding experiment with zero lint warnings and instant builds is even better.\n"}]},{"day":"2026-08-20","entries":[{"slug":"shader-f16-m4-pro","title":"Pushing the Apple M4 Pro with half-precision compute","date":"2026-08-20T23:42:00.000Z","tags":["WebGPU","Performance","Optimization"],"thread":"mujo-watercolor","body":"\n**Sustaining 120 FPS on a 9-million cell fluid grid requires militant GPU memory management.** To hit our performance targets on Apple Silicon without dropping frames, we moved the entire simulation pipeline to `rgba16float` (f16) half-precision math. The real breakthrough was consolidating Navier-Stokes advection, Jacobi pressure projection, and capillary diffusion into a single zero-allocation GPU command submission per frame. By eliminating runtime bind group creation, the M4 Pro chews through 3072² grids with almost zero latency.\n"},{"slug":"mujo-atelier-5-lab-experiments","title":"MUJŌ Atelier: 5 lab experiments for the physics engine","date":"2026-08-20T15:00:00.000Z","tags":["WebGPU","MUJŌ","Benchmarks"],"thread":"mujo-watercolor","body":"\n**Built a companion scientific testbed — MUJŌ Atelier — with 5 standalone lab experiments.** Each experiment isolates and compares one physics layer: Darcy tensor diffusion vs. Lattice Boltzmann D2Q9 fluid bleed, single-layer Kubelka-Munk vs. Saunderson 3-layer glaze stacks, 6 botanical washi substrates with different fiber structures, and an M4 Pro hardware profiler measuring per-pass GPU timings. The Atelier is the \"show your work\" for the simulation — same ethos as the Gemma 4 benchmark suite, different domain. If someone asks \"how does your Kubelka-Munk compare to LBM?\" the answer is a side-by-side live experiment, not a paragraph.\n"},{"slug":"automated-verification","title":"Building an automated verification harness for brush feel","date":"2026-08-20T01:32:00.000Z","tags":["Testing","Engineering","Tooling"],"thread":"mujo-watercolor","body":"\n**We were taking one step forward and two steps back tuning the subjective feel of the brush.** After repeatedly losing the \"magic\" of a good stroke to regression bugs, I realized we needed a methodical way to evaluate tweaks. I built an automated visual comparison suite that captures macro and micro snapshots of kanji character strokes across a speed ladder. By running side-by-side A/B baselines, we can finally prove whether a new physical tip lag or viscosity adjustment is actually an improvement or just a different flavor of wrong.\n"}]},{"day":"2026-08-19","entries":[{"slug":"killing-the-caterpillar-eliminating-vector-art-artifacts","title":"Killing the caterpillar: eliminating vector-art artifacts","date":"2026-08-19T16:00:00.000Z","tags":["WebGPU","MUJŌ","Debugging","Shaders"],"thread":"mujo-watercolor","body":"\n**Spent two days hunting and killing every artifact that made the strokes look digital instead of organic.** The \"caterpillar beads\" — visible blob spacing along fast strokes — were eliminated by switching to Catmull-Rom C1 spline interpolation with lag-by-one future-point basis. The \"reed-screen grating\" came from frame-boundary discontinuities in bristle injection, fixed by continuous sub-frame interpolation. Then the needle artifact at stroke ends: a kinematic speed/pressure gate smoothly tapers the contact area to zero. Finally, added *fude-ashi* bristle fringes and tooth gating so even straight lines have the organic irregularity of real ink on handmade paper. The Shisho benchmark suite (永永字八法, 一 ichi, 心 kokoro, 円 ensō) now produces strokes that would fool a calligrapher at thumbnail scale.\n"}]},{"day":"2026-08-18","entries":[{"slug":"jagged-strokes","title":"Fixing stair-stepped brush strokes with timestamp kinematics","date":"2026-08-18T04:23:00.000Z","tags":["Input","Kinematics","Math"],"thread":"mujo-watercolor","body":"\n**Fast brush flicks were starving the interpolation curve, leaving ugly jagged staircase edges on the canvas.** When relying strictly on raw coordinate deltas, rapid trackpad swipes didn't provide enough data points for smooth splines. The fix was moving to a timestamp-normalized kinematic model. I implemented a dynamic Centripetal Catmull-Rom ingester that scales subdivision steps based on true elapsed millisecond velocity. Now, even a 2,500px/s flick renders with perfect tangent continuity and natural taper.\n"}]},{"day":"2026-08-17","entries":[{"slug":"48-elastic-bristle-rods-on-the-gpu","title":"48 elastic bristle rods on the GPU","date":"2026-08-17T14:30:00.000Z","tags":["WebGPU","MUJŌ","Shaders","Animation"],"thread":"mujo-watercolor","body":"\n**Replaced the simple swept-capsule brush with 48 Position-Based Dynamics elastic guide rods running entirely in WGSL compute shaders.** Each bristle has distance constraints, bending rigidity, Coulomb friction against the paper surface, and capillary clumping when wet. The brush fans out under pressure, pinches on turnarounds, and flicks on lift-off with real inertia. Three brush types: Maru-fude (round calligraphy), Menso (fine liner), and Hake (broad wash). The difference is visceral — strokes went from \"digital stamp\" to \"I can feel the paper\" in one refactor. Also added a procedural Web Audio soundscape: bamboo water drops, singing bowls, and paper friction acoustics that respond to brush pressure.\n"},{"slug":"washi-substrates","title":"Modeling botanical fiber topologies for Japanese washi","date":"2026-08-17T02:49:00.000Z","tags":["Procedural Generation","Shaders","Design"],"thread":"mujo-watercolor","body":"\n**The capillary mechanics of fluid change drastically depending on the paper's microscopic fiber skeleton.** I expanded the `parchment_gen.wgsl` shader to 141 lines to procedurally generate three distinct traditional substrates: Kizuki Kōzo (unbleached mulberry), Torinoko (sized eggshell), and Kobishi (vintage tea-tannin). By tracking physical tangents along the sinuous bast fibers, the fluid dynamics solver now knows exactly where to pool and where to bleed aggressively, matching the distinct behaviors of each paper type.\n"}]},{"day":"2026-08-16","entries":[{"slug":"saunderson-glaze","title":"Testing the Saunderson multi-layer glaze stack","date":"2026-08-16T22:20:00.000Z","tags":["Optics","Color Science","Research"],"thread":"mujo-watercolor","body":"\n**A single Kubelka-Munk layer isn't enough to capture internal light bounces inside the pigment pool.** I built a 659-line experimental lab to compare our baseline Kubelka-Munk output against a full Saunderson 3-layer glaze matrix. The goal was to accurately render the *Fuchidori* (coffee-ring borders) and refractive-index matching wet-darkening. Factoring in Fresnel internal reflections proved computationally heavy, but the optical depth it adds to the drying decay of the watercolor pools is unmistakable.\n"},{"slug":"kubelka-munk","title":"Ditching RGB alpha for Kubelka-Munk optical mixing","date":"2026-08-16T18:24:00.000Z","tags":["Color Science","Shaders","WebGPU"],"thread":"mujo-watercolor","body":"\n**Standard RGB alpha blending completely ruins the luminosity of digital watercolor.** Layering yellow over indigo usually produces a muddy, desaturated grey in traditional digital canvases. To fix this, I wrote a 140-line `render_km.wgsl` shader implementing a robust 2-flux Kubelka-Munk radiative transfer model. By using true physical spectral values (absorption K and scattering S), the pigments now interact subtractively just like real minerals—yielding deep, authentic celadon greens and vibrant glazes that maintain the optical reality of actual paint.\n"},{"slug":"lbm-vs-darcy","title":"Lattice Boltzmann vs. Darcy flow for capillary tendrils","date":"2026-08-16T00:51:00.000Z","tags":["Fluid Dynamics","WebGPU","Research"],"thread":"mujo-watercolor","body":"\n**Lattice Boltzmann provides incredible fluid mechanics, but it devours memory bandwidth on Apple Silicon.** I set up an A/B test in a 696-line `FluidBleedExperiment.ts` harness to compare an LBM D2Q9 model against an anisotropic Darcy tensor for simulating the lush capillary tendrils (*Hige-nijimi*) of watercolor bleed. While LBM is mathematically elegant, it bottlenecked the unified memory architecture. We pivoted to a 2-layer Darcy porous flow with saturation gating—yielding a stable WebGPU compute pipeline that visually matches the organic wicking without the performance penalty.\n"}]},{"day":"2026-08-15","entries":[{"slug":"bristle-physics","title":"Taming the 3D Cosserat hair physics","date":"2026-08-15T19:28:00.000Z","tags":["WebGPU","Simulation","Physics"],"thread":"mujo-watercolor","body":"\n**Getting the physical tip lag right was a massive battle against stiffness and chaotic particles.** I spent hours dialing in a discrete 3D Cosserat elastic rod simulation for the brush bristles, implemented in a 287-line `CosseratBristleCluster.ts` file. Early iterations were either too rigid or produced bizarre, sperm-like particle trails that broke the meditative vibe. By tuning the bending stiffness and stepping the physics at 0.016s intervals, we finally achieved a natural viscoelastic lag that responds organically to trackpad pressure and momentum.\n"},{"slug":"mujo-first-ink-on-digital-washi","title":"MUJŌ: first ink on digital washi","date":"2026-08-15T17:20:00.000Z","tags":["WebGPU","MUJŌ","Shaders"],"thread":"mujo-watercolor","body":"\n**Built a complete WebGPU watercolor simulation engine in a single session.** MUJŌ (無常) — a meditative Japanese sumi-e painting canvas running entirely on GPU compute shaders. No Three.js, no React, no external physics libraries. Custom Navier-Stokes fluid solver, 2-flux Kubelka-Munk spectral color mixing, and Darcy porous flow through virtual paper fibers. Five authentic Nihonga mineral pigments — sumi carbon black, cinnabar vermilion, fermented indigo, yellow ochre, malachite verdigris — each with real spectral absorption/scattering tables. The ink bleeds through virtual Kozo mulberry fibers and darkens along evaporating edges. 1024×1024 simulation grid running at interactive framerates on M4 Pro.\n"}]},{"day":"2026-08-14","entries":[{"slug":"snakes-that-looked-like-a-bag-of-shapes","title":"Snakes that looked like a bag of shapes until Catmull-Rom saved them","date":"2026-08-14T21:24:00.000Z","tags":["Creative","Procedural Graphics"],"thread":"snakes-on-a-screen-build","body":"$36"},{"slug":"compositing-a-brooklyn-loft-keynote-studio-at-60fps","title":"Compositing a Brooklyn loft keynote studio at 60fps","date":"2026-08-14T21:15:00.000Z","tags":["Canvas","React","Video","UX"],"thread":"hair-raising-demogod-build","body":"\n**Turned a raw webcam feed into a polished tech keynote studio without touching an external broadcast tool.** Wrote a 665-line HTML5 Canvas compositor in `StudioRenderer.ts` that layers background environments, presenter avatars, studio lighting, and foreground props in a single 60 FPS render loop. The camera face-swap mode uses a feathered elliptical clipping aperture centered on the nose landmark to blend real webcam video onto a custom procedural crewneck shirt. Added studio props right on the virtual desk: a Google DeepMind laptop with a gradient I/Ø badge and a yellow ribbed ceramic coffee mug. Integrated a built-in auto-scrolling teleprompter with adjustable speed and font size directly above the lens line so eye contact never drops. For recording, `RecordingEngine.ts` captures the 60 FPS canvas stream and mixes microphone audio locally using `MediaRecorder`, outputting ready-to-share WebM clips with zero cloud processing.\n"},{"slug":"clouds-in-the-cabin-and-the-right-click-mutiny","title":"Clouds in the cabin and the right-click mutiny","date":"2026-08-14T20:58:00.000Z","tags":["Creative","Design"],"thread":"snakes-on-a-screen-build","body":"\n**First playtest: the clouds were passing straight through the fuselage walls into the cabin.** Pretty, but also pretty distracting when you're trying to spot a green viper under row 18. Killed the volumetric cloud geometry entirely — replaced the exterior with clean gradient sky planes visible through the window cutouts, and shifted the rendering budget to cabin detail: emergency floor strip lighting, seat headrest textures, galley cart geometry. The second problem was worse. Right-click to shoot? On a laptop trackpad? Nobody right-clicks fast enough to zap a rattlesnake mid-lunge. Remapped the whole control scheme: spacebar for precision taser, `F` for EMP shockwave, arrow keys for turning, `C` for crouching under seats. Now it plays like a game instead of a tech demo. The lesson: build the full feature first, then play it yourself and listen to what's annoying. The clouds looked great in screenshots. They were terrible in gameplay.\n"},{"slug":"5229-lines-of-snake-zapping-fps-in-one-evening","title":"5,229 lines of snake-zapping FPS in one evening","date":"2026-08-14T20:48:00.000Z","tags":["Creative","Vibe Coding"],"thread":"snakes-on-a-screen-build","body":"\n**Started with a single sentence — \"zap a snake on a plane\" — and had a playable 3D first-person shooter running in the browser nine minutes after approving the plan.** 18 TypeScript source files, a procedural airplane cabin with carpeted aisles and overhead bins, 5 snake species with different health pools and behaviors, a TAS-9000 stun gun with precision bolts and wide-angle EMP, a 3-stage campaign from Economy to Cockpit, and a Web Speech API pilot announcer delivering comedic PA lines through a bandpass radio filter. The whole thing runs on Three.js r170, zero art assets, zero external dependencies beyond the renderer. Every texture is procedural. Every sound is Web Audio API oscillator synthesis — taser crackles, airline chimes, spatial rattlesnake tails. The 285-line `index.html` is a full 90s CRT in-flight entertainment UI with scanline filters and a briefing screen. Pure prompt-to-game, no starter template, no boilerplate.\n"},{"slug":"the-320-percent-hair-slider-that-bounces-when-i-talk","title":"The 320% hair slider that bounces when I talk","date":"2026-08-14T19:35:00.000Z","tags":["Canvas","WebAudio","Creative Coding","Physics"],"thread":"hair-raising-demogod-build","body":"\n**I wanted a presentation setup where my hair reacts to my voice and defies physics in real time.** Built a parametric hair rendering engine in `HairEngine.ts` (449 lines) backed by MediaPipe's 468-point 3D face mesh. Instead of static overlay PNGs, the hair is rendered dynamically with height scaling up to 320%, horizontal volume expansion to 200%, and Marschner-style anisotropic specular highlights. Connected a second-order spring-damper model with 0.88 damping and 0.22 stiffness to head yaw and pitch velocities, so turning your head produces satisfying inertia recoil. Added real-time voice reactivity via the Web Audio API FFT analyzer, isolating speech frequency bins 2 through 45 (150 Hz to 3 kHz) to pulse the pompadour height upward whenever speaking. When you push height past 1.25x, 18 procedural bezier curves stitch seamless sky-high hair extensions, while 28 glint particles sparkle across the crest. It is completely absurd and completely impossible to stop playing with.\n"},{"slug":"two-bugs-and-the-tab-overflow-nobody-saw-coming","title":"Two bugs and the tab overflow nobody saw coming","date":"2026-08-14T13:31:00.000Z","tags":["Apple Silicon"],"thread":"personal-pomodoro-build","body":"$37"},{"slug":"stats-sounds-and-shipping-dockless","title":"Stats dashboard, sound picker, and shipping dockless","date":"2026-08-14T13:30:00.000Z","tags":["Swift","Apple Silicon"],"thread":"personal-pomodoro-build","body":"$38"},{"slug":"snooze-penalties-that-actually-work","title":"Snooze penalties: the feature that makes a timer actually work","date":"2026-08-14T13:26:00.000Z","tags":["Swift","Apple Silicon","Design"],"thread":"personal-pomodoro-build","body":"$39"},{"slug":"menu-bar-app-in-14-minutes","title":"A full macOS menu bar app in 14 minutes flat","date":"2026-08-14T13:16:00.000Z","tags":["Swift","Apple Silicon"],"thread":"personal-pomodoro-build","body":"\n**Tested Gemini 3.7 Flash by asking it to build a native macOS Pomodoro timer from scratch — and it delivered a complete menu bar app in a single session.** 18 Swift files, zero external dependencies, running dockless via `NSApp.setActivationPolicy(.accessory)`. The app lives in the macOS status bar as a 🍅 icon, opens a 330×550 glass popover with `NSPopover`, and ticks down via `DispatchSourceTimer` at 250ms intervals against a wall-clock `targetEndDate` so the countdown stays accurate even if the system sleeps. The model chose SPM over Xcode, wired `MenuBarController` through Combine's `objectWillChange` to keep the menu bar title reactive, and even handled click-outside-to-dismiss with a global event monitor. No hand-holding, no corrections — the architecture decisions were the model's.\n"}]},{"day":"2026-08-13","entries":[{"slug":"six-floating-struts-and-an-interactive-molecular-codex","title":"Six floating struts and an interactive molecular codex","date":"2026-08-13T18:15:00.000Z","tags":["Three.js","Physics","React"],"thread":"buckybounce-physics-lab","body":"\n**Rebuilding BuckyBounce into a full structural laboratory meant expanding far beyond fullerenes to simulate true tensegrity dynamics in Three.js.** Constructed a 6-strut tensegrity icosahedron where 6 rigid compression bars remain completely isolated from one another, suspended purely in dynamic equilibrium by 24 continuous elastic tension tendons. To transform the toy into an educational engine, built 666 lines of pedagogical interfaces spanning an interactive 3D Codex modal, structural puzzle challenges, and an AI Architect prompt interface that uses structured Gemini JSON schemas to generate custom spring constants and gravity vectors on the fly. Handled 6 distinct structural allotropes across 670 lines in `geometry/structures.ts`, wiring real-time Euler polyhedral validation into the HUD. Shipped 3,530 insertions across 21 files in commit `519aa35` after 513 agent steps, turning a simple bouncing sphere into a deep material science playground.\n"},{"slug":"stress-lab-resonance-sweeps-and-yield-fracture","title":"Resonance sweeps, strain heatmaps, and yield-stress fracture","date":"2026-08-13T17:56:00.000Z","tags":["Visualization","Animation","React"],"thread":"buckybounce-physics-lab","body":"\n**Upgraded BuckyBounce into a structural mechanics laboratory featuring 6 allotropes, harmonic resonance sweeps, and catastrophic bond fracture.** Expanded the geometry engine beyond $C_{60}$ to generate $C_{70}$ fullerenes, $(5,5)$ armchair carbon nanotubes, graphene honeycomb sheets, geodesic domes, and 6-strut tensegrity icosahedrons with isolated compression bars suspended in continuous tension networks. Implemented a harmonic driving oscillator to sweep excitation frequencies ($\\omega$) and reveal natural eigenmode vibrations in real time. Dynamic vertex shaders map Hooke's strain tensors into thermal heatmaps (cyan $\\to$ yellow $\\to$ red), triggering covalent bond snapping when local strain exceeds yield strength—complete with a laser-weld synthesis tool to reconstruct shattered lattices atom by atom.\n"},{"slug":"topological-face-extraction-and-euler-target-rings","title":"Topological face extraction and Euler target rings","date":"2026-08-13T17:40:00.000Z","tags":["Visualization","Animation","Design"],"thread":"buckybounce-physics-lab","body":"\n**To turn an elastic bouncing buckyball into an arcade physics challenge, the engine needed to recognize molecular faces rather than just raw vertices and edges.** Implemented a chordless minimal cycle traversal algorithm that parses the raw node-link graph to automatically detect 2-manifold faces, extracting exactly the 12 pentagons and 20 hexagons governed by Euler's polyhedral formula ($V - E + F = 2$). Transformed the 12 pentagonal topological defects into glowing holographic target rings oriented along their outward surface normals. Built a high-speed projectile slingshot mechanic that lets you fire particle probes through the molecular cage, rewarding precision ring threading with procedural pentatonic chime sweeps and exponential combo multipliers when ricocheting off interior nodes.\n"}]},{"day":"2026-08-12","entries":[{"slug":"actual-eclipse-still-had-the-app","title":"An actual eclipse happened and I still had the app","date":"2026-08-12T16:52:00.000Z","tags":["React"],"thread":"red-eclipse-build","body":"\n**Built a lunar eclipse tracker for the March 2026 event, shelved it, then on August 12th a real solar eclipse happened and the whole thing became relevant again.** Fired it up to record a screen demo — the globe still spins, the weather telemetry still pulls, the countdown still ticks against the demo offset. But the bigger move was using the original as a reference architecture to prompt AI Studio for a v2: same 3D globe and atmosphere vibe, same user-location positioning, but themed for a solar eclipse instead of lunar, with potential Google Maps grounding for the path of totality. The original app was never meant to outlive one event, but here it is — a reusable template that proved its structure works well enough to fork forward.\n"},{"slug":"red-eclipse-assets","title":"Screen recording and animation assets","date":"2026-08-12T14:00:00.000Z","tags":["assets","demo"],"thread":"$undefined","body":"\nFinalized the high-quality screen recordings and animated GIFs required to showcase the eclipse visualization on the portfolio, working through initial framerate and CSS rendering glitches.\n"},{"slug":"red-eclipse-visualization","title":"August 2026 Eclipse visualization","date":"2026-08-12T12:00:00.000Z","tags":["visualization","webgl","animation"],"thread":"$undefined","body":"\nBuilt a web-based visualization to celebrate the August 12, 2026 total solar eclipse. The app accurately maps the path of totality and provides an immersive visual countdown.\n"}]},{"day":"2026-08-08","entries":[{"slug":"1058-lines-of-shader-still-fighting-starfield","title":"1,058 lines of shader and still fighting the starfield","date":"2026-08-08T17:00:00.000Z","tags":["Shaders","React"],"thread":"cloud-9-countdown-build","body":"$3a"},{"slug":"telling-an-ai-what-30-percent-scroll-looks-like","title":"How do you tell an AI what 30% scroll looks like when you can't agree on the viewport?","date":"2026-08-08T16:00:00.000Z","tags":["Creative"],"thread":"$undefined","body":"$3b"},{"slug":"scroll-by-scroll-teaching-an-ai-to-see","title":"Scroll-by-scroll: teaching an AI to see what's wrong","date":"2026-08-08T14:00:00.000Z","tags":["Design"],"thread":"cloud-9-countdown-build","body":"$3c"},{"slug":"the-vision-gap","title":"The vision gap: what I saw vs. what the agent built","date":"2026-08-08T01:00:00.000Z","tags":["Creative"],"thread":"cloud-9-countdown-build","body":"$3d"}]},{"day":"2026-08-07","entries":[{"slug":"the-portfolio-triage-dashboard-nobody-asked-for","title":"The portfolio triage dashboard nobody asked for","date":"2026-08-07T21:11:00.000Z","tags":["AI Studio","Infrastructure","Design"],"thread":"automating-ai-studio","body":"$3e"},{"slug":"killed-nextjs-shipped-370-lines-of-scroll","title":"Killed the Next.js version and shipped 370 lines of pure scroll","date":"2026-08-07T21:00:00.000Z","tags":["React Three Fiber","Shipping"],"thread":"$undefined","body":"\n**The Next.js version was 1,058 lines of page.tsx with layered PNGs, GSAP, and a scroll system that fought itself.** I'd been wrestling with it across six sessions, but the real problem wasn't the code — it was the architecture. Next.js SSR and React Three Fiber's scroll controls don't love each other. So I started fresh: Vite + React 19, one App.tsx, volumetric clouds from drei's raymarched `` components instead of PNG layers, 800 Gemini-colored star particles with per-frame CPU physics, and a scroll-driven camera dive from bright sky to dusk. 370 lines. One file. No API keys, no backend, no server-side rendering pretending to be a 3D experience. Changed the golden \"9\" from white to sun-colored because white-on-white clouds was invisible. Generated a new Shoreline Amphitheatre image to replace the placeholder. Pushed to GitHub the same night.\n"},{"slug":"26-minutes-to-github-ready","title":"26 minutes from 'let's see what this does' to pushed on GitHub","date":"2026-08-07T20:25:00.000Z","tags":["AI Studio","Shipping"],"thread":"prompt-driven-physics-timer","body":"$3f"}]},{"day":"2026-08-04","entries":[{"slug":"react-19-hiding-inside-nextjs-broke-the-3d-stack","title":"React 19 hiding inside Next.js 16 broke the whole 3D stack","date":"2026-08-04T03:12:00.000Z","tags":["AI Studio","React","Debugging"],"thread":"snow-temp-3d-viz-rescue","body":"\n**Upgrading Next.js to fix 48 CVEs broke everything I'd just cleaned up.** The security audit on the weather viz export showed 48 vulnerabilities including 4 critical — all rooted in Next.js 14.2.15 and its transitive `postcss` and `glob`. Every Next.js 14.x version was in the vulnerable range, so I jumped to 16.3.0. Build passed. Then `ReactCurrentBatchConfig is not defined` at prerender time. The culprit: Next.js 16 bundles React 19.3 internally, but my `package.json` had React 18.3.1, and React Three Fiber 8.x only supports `react >=18 <19`. Two different Reacts in the same build. No bridge version exists — R3F 9 is React 19 only. So I upgraded the entire ecosystem in one shot: React 19, R3F 9.7.0, drei 10.7.7, Three.js 0.185. Clean `npm install` — 0 vulnerabilities, 0 peer warnings, no `--legacy-peer-deps`. Build passed. Dev server booted. 3D snow scene rendered. From 48 CVEs to zero in one dependency cascade.\n"},{"slug":"lazy-keys-and-real-gpus-shipping-terragemini","title":"Lazy keys and real GPUs: shipping TerraGemini to GitHub","date":"2026-08-04T01:15:00.000Z","tags":["AI Studio","Shipping","WebGL","Automation"],"thread":"terragemini-build","body":"$40"}]},{"day":"2026-08-03","entries":[{"slug":"dot-matrix-earth-export-to-github-in-ten-minutes","title":"Dot-matrix Earth: export zip to GitHub in ten minutes","date":"2026-08-03T22:55:00.000Z","tags":["React","AI Studio"],"thread":"ais-rotating-earth-build","body":"\n**Asked the agent to spin it up and ship it — one conversation later, the whole thing was on GitHub with a README, screenshots, and a GIF.** Killed a duplicate texture load (two 2K images fetching from CDNs, only one wired to the shader), fixed Tailwind content globs that were scanning all of `node_modules`, removed the cleanup scaffolding, captured Playwright screenshots at headless 2x DPR, assembled 48 GIF frames at 10fps into a 4.9MB demo loop. One commit, 17 files, 3,990 lines inserted. The interesting moment came after shipping: I noticed the dot-matrix pattern trades away continental detail for the stylized look — the coastlines felt overexposed, the interior dots too uniform. Turns out that's the shader's deliberate choice. `dotDensity: 110` and a `smoothstep(0.2, 0.6)` coastline threshold are tuned aggressive on purpose. The dots aren't trying to be a map. They're trying to be a mood.\n"},{"slug":"six-files-zero-ai-one-custom-shader","title":"Six files, zero AI, one custom shader","date":"2026-08-03T22:49:00.000Z","tags":["React","AI Studio","Shaders"],"thread":"ais-rotating-earth-build","body":"\n**Dropped into a blind AI Studio export and found something I didn't expect: no Gemini API, no backend, no env vars — just a 255-line React component with two custom GLSL shaders doing all the work.** A fragment shader samples a 2K specular map to separate land from ocean, tiles a UV-space dot grid across the sphere with `smoothstep` circles, and runs a Sobel-like edge filter on four neighboring texels to trace coastlines in real time. An atmosphere shader fakes edge glow with view-angle falloff. The whole thing renders on a 128-segment sphere geometry behind an occlusion sphere that hides backface dots. Two fixes to get it running — a missing CSS file and a CDN importmap fighting Vite's bundler — and it was rendering at 60fps. Cleanest AI Studio export I've seen: zero surgery, zero dead dependencies, zero scaffold cruft worth worrying about.\n"},{"slug":"70-gif-frames-12-sizes-zero-consistency","title":"70 GIF frames, 12 different sizes, zero consistency","date":"2026-08-03T22:30:00.000Z","tags":["Automation","Infrastructure"],"thread":"red-eclipse-build","body":"\n**The demo GIF was 5 MB of jitter — 70 frames at 12 different dimensions, from 800×517 down to 797×438.** Only 48 frames matched the target size. The screenshots were retina-scale but the README still had placeholder URLs. AI Studio exports always ship with the same invisible baggage: a duplicate `.eslintrc.json` next to the flat config, an HMR-disabling webpack block nobody asked for, `output: 'standalone'` for Docker deployments that will never happen, and a `picsum.photos` remote pattern because every Next.js template apparently loves stock photos. Tore all of it out, moved misplaced build deps from `dependencies` to `devDependencies`, killed the dead `autoprefixer` and `@tailwindcss/typography` packages, patched three `npm audit` vulnerabilities with overrides, generated an SVG favicon, and recaptured the screenshots headless at consistent dimensions. One commit, zero scaffold left.\n"},{"slug":"not-everything-needs-a-gradient-and-a-dark-theme","title":"Not everything needs a gradient and a dark theme","date":"2026-08-03T21:21:00.000Z","tags":["AI Studio","Canvas","Animation"],"thread":"stick-figure-countdown","body":"\n**Cleaned up the stick figure animation — killed dead deps, fixed 14 console errors, wrote the README, captured the GIF — and then ruined it.** Added a dark theme, glassmorphic eyes, animated gradient backgrounds, ambient floating particles. It looked premium. It looked like every other polished demo. It looked nothing like a stick figure doing ninja shit on a white background, which was the entire point. Caught myself mid-ship: the inspiration was xiao xiao, Animator vs. Animation — bold black lines, stark white, zero ornamentation. The restraint IS the design. Reverted everything visual, kept every structural fix underneath. The diff: 45 insertions, 235 deletions. Less code shipped a better product. That session taught me enough to write a permanent rule about it — don't override deliberate aesthetic choices just because you can make it shinier.\n"},{"slug":"the-rescue-that-wrote-its-own-playbook","title":"The rescue that wrote its own playbook","date":"2026-08-03T17:29:00.000Z","tags":["AI Studio","Automation"],"thread":"will-it-fit-build","body":"$41"},{"slug":"will-it-fit-spatial-reasoning-that-works","title":"Will it fit? The spatial reasoning app that actually works","date":"2026-08-03T17:08:00.000Z","tags":["Imagen","AI Studio"],"thread":"will-it-fit-build","body":"$42"},{"slug":"eleven-models-one-commit-and-a-three-js-solar-system","title":"Eleven models, one commit, and a Three.js solar system","date":"2026-08-03T14:10:00.000Z","tags":["AI Studio","Shipping"],"thread":"vibe-bench","body":"\n**Shipped an AI Studio export to GitHub in one session — but the 'fix somethings' turned into a React ecosystem upgrade.** R3F 8→9, drei 9→10, recharts 2→3, lucide 0.344→1.28, all to get React 19 compatibility. Clean install, zero peer dep warnings, zero vulnerabilities. The app ranks 11 image-gen models — Gemini 3 Pro, Imagen 4 Ultra, GPT Image 1, Hunyuan, Seedream, Wan — by ELO and a six-axis 'Vibe Score' (chill, intellect, creativity, basedness, humor, safety). The hero is a Three.js scene with a noise-displaced icosahedron core orbited by model planets, 1,000 instanced particles, and connection lines. The Vibe Check tab sends prompts to Gemini 2.5 Flash with a structured JSON schema that forces scores on all six axes. 1,415 lines of code. One commit. The whole thing fits in your head if you squint — but the GLSL vertex shader alone is 60 lines of simplex noise.\n"},{"slug":"38-frame-sizes-in-one-gif","title":"38 frame sizes in one GIF — fixing the screenshot disaster","date":"2026-08-03T13:21:00.000Z","tags":["AI Studio","Playwright"],"thread":"google-io-concierge","body":"\n**Opened the repo on GitHub and the demo GIF looked like it was having a seizure.** 38 different frame dimensions ranging from 1×1 to 800×414 — the GIF encoder was spitting out delta-compressed patches as individual frames. The hero screenshot was worse: a 2880×1490 desktop capture with my IDE chrome bleeding into the frame. Not exactly portfolio material. The fix was Playwright headless at iPhone 14 viewport (390×844 @2x), capturing the production build. Three clean screenshots — dashboard, session detail, Gemma chat — plus 52 consistent frames assembled into a 272KB GIF. Had to fight `__dirname` resolution twice when the capture script ran from the wrong scope. Also created an SVG favicon (the manifest referenced `favicon.ico` but no file existed), rewrote the README to lead with the demo GIF, killed the dead `@google/genai` dependency, moved `autoprefixer` out of production deps, and fixed the Next.js 15 `themeColor` viewport warning. Two commits, 14 files changed, zero Dependabot alerts.\n"},{"slug":"glassmorphism-at-1am-and-the-commit-that-never-pushed","title":"Glassmorphism at 1 AM and the commit that never pushed","date":"2026-08-03T01:19:00.000Z","tags":["AI Studio","Design"],"thread":"io-highlights-tracker-rescue","body":"$43"},{"slug":"clear-the-embarrassment","title":"Clear the embarrassment: when your shipped repo needs a second take","date":"2026-08-03T00:34:00.000Z","tags":["AI Studio"],"thread":"chronos-visual-time-rescue","body":"\n**Looked at the repo after the first rescue pass and got hit with terrible screenshots and leftover cruft.** The GIF was 1.4 MB of blurry captures, the package was still named `react-example`, and dead scaffold files survived the cleanup. So I called a do-over — spawned a research subagent to audit every file, stripped the package name, removed `class-variance-authority` and other shadcn ghosts that were never imported, recaptured all media via Playwright headless at proper viewport sizes, and added a filtered-state screenshot showing the continent nav. Three Playwright capture passes to get the framing right — the first two had crop issues. The `/learn` at the end of this session is what eventually became the WebGL capture rules in my global config. Sometimes shipping means shipping twice.\n"},{"slug":"four-models-one-missing-color","title":"Four models, one missing color, and a screenshot of my own IDE","date":"2026-08-03T00:15:00.000Z","tags":["AI Studio","Infrastructure"],"thread":"$undefined","body":"$44"},{"slug":"runtime-error-as-the-hero-image","title":"Runtime error as the hero image — that's a new low","date":"2026-08-03T00:00:00.000Z","tags":["AI Studio","Recharts"],"thread":"$undefined","body":"$45"}]},{"day":"2026-08-02","entries":[{"slug":"beautiful-ui-hollow-backend","title":"Beautiful UI, hollow backend — the I/O Concierge recon","date":"2026-08-02T22:44:00.000Z","tags":["AI Studio","React","PWA"],"thread":"google-io-concierge","body":"\n**Ran the recon on a Google I/O companion app I built in AI Studio and found out it's gorgeous theater.** The design is genuinely good — purple gradients, spring physics on the bottom sheet, Motion transitions between views, offline banners, a Gemma \"On-Device\" chat interface with quick-reply pills. It *feels* like a native conference app. Then I looked at the source: 1,125 lines in a single `page.tsx`. The `@google/genai` SDK is in `package.json` but zero lines of source code import it. The chat? `setTimeout` with a hardcoded response. The \"syncing...\" indicator on session notes? Another `setTimeout`. The countdown timer counts down to nothing. Every single \"smart\" feature is a `setTimeout` wearing a nice outfit. But the design instincts — the color system, the animation choreography, the mobile-first feel — that's the real asset. AI Studio gave me a portfolio-grade UI mockup. It just forgot to mention it wasn't real.\n"},{"slug":"dropped-into-a-dark-room-with-a-zip-file","title":"Dropped into a dark room with a zip file and a Gemini key","date":"2026-08-02T22:43:00.000Z","tags":["AI Studio","React"],"thread":"io-highlights-tracker-rescue","body":"\n**Started the AI Studio recon workflow on a Google I/O highlights tracker — an app that generates fictional conference announcements via Gemini and renders them in a card grid.** The export compiled clean on the first `npm install && npm run build` — zero TypeScript errors, zero missing deps — which is rare for AI Studio zips. But the security model was broken from birth: `vite.config.ts` used a `define` block to inline `process.env.API_KEY` as a string literal into the client bundle, meaning any deployed build would bake the Gemini key into publicly downloadable JavaScript. The app worked, though: 8 source files, 652 lines of TypeScript, Vite + React 19 + Tailwind 3 + `@google/genai` SDK. Hit the Gemini 2.5 Flash endpoint with a mega-prompt that asks the model to generate plausible I/O announcements grounded via Google Search, parse the JSON response, group by category, and render timestamped cards with status badges. Shipped a recon report and moved on to the real work.\n"},{"slug":"672-lines-of-someone-elses-physics","title":"672 lines of someone else's physics — and it actually runs","date":"2026-08-02T19:30:00.000Z","tags":["React","AI Studio"],"thread":"neon-hoberman-rescue","body":"\n**Came back to the Hoberman sphere six days after the recon, still not sure I'd ship it.** \"Can you get this running locally first so I can see what it is?\" — that was the ask. What I saw was spring physics on a dodecahedron wireframe, atoms that explode and heal, bloom and vignette post-processing, an AI remix engine that generates color palettes from vibes. All from someone else's AI Studio prototype. The rescue list: ripped out Tailwind CDN for a native v4 install, added a collapsible controls panel so you could actually see the sculpture, built a missing API key warning that degrades gracefully, fixed React unmount leaks (tracked timeouts with refs), and disposed Three.js geometries after graph extraction to stop GPU memory from bleeding. One commit, 18 files, 4,298 insertions. Screenshots, a demo GIF, a README that starts with the GIF. Pushed to GitHub. From \"can I even see what this is\" to shipped repo in one evening.\n"},{"slug":"the-ais-to-github-pipeline-that-taught-itself","title":"The AIS-to-GitHub pipeline that taught itself","date":"2026-08-02T19:21:00.000Z","tags":["Infrastructure","Automation","AI Studio"],"thread":"isoglobe-weather-build","body":"\n**Shipped IsoGlobe Weather to GitHub and then immediately did a retrospective that became a permanent rule update.** The cleanup pass deleted scaffold files, stripped 8 unused imports, replaced `Math.random()` with deterministic hashing, swapped screenshots for dramatic injected state captures (rich Tokyo snow scene at night vs. the sparse 6-cell fallback), and wrote a README with a two-screenshot hero table. But the real outcome was the `/learn` session afterward: documented four new rules — `ais-` prefix on repos, mandatory demo GIF for animated apps, run dead dep audits yourself instead of delegating to subagents, and always skim the `ai-studio-export-rescue` skill even if the app already boots. The project that taught the pipeline how to run.\n"},{"slug":"flickering-buildings-and-deterministic-hashing","title":"Flickering buildings and deterministic hashing","date":"2026-08-02T19:02:00.000Z","tags":["React","Debugging"],"thread":"isoglobe-weather-build","body":"\n**Caught a subtle rendering bug that AI Studio's scaffold would have shipped: buildings changing colors on every re-render.** The original code picked building colors with `Math.random()` inside a `useMemo` hook — so each state update reshuffled the entire cityscape. Replaced it with a seeded deterministic hash (`Math.abs(Math.sin(i * 12.9898 + 78.233) * 43758.5453) % 1`) indexed into the theme's color array. Same fix for window light placement and tree positioning. The city now looks stable across re-renders while still appearing randomly distributed. Also added `try/catch` around `JSON.parse()` in the Gemini service — without it, a malformed response crashes the app silently. These are the bugs that pass `npm run build` but break the experience.\n"},{"slug":"five-cities-three-states-one-globe","title":"Five cities, three states, one globe","date":"2026-08-02T18:46:00.000Z","tags":["Visualization"],"thread":"isoglobe-weather-build","body":"\n**Plugged in a real API key and took the globe on a five-city tour — Tokyo, New York, Reykjavik, São Paulo, LA — and every city looked completely different.** Tokyo at night: dense grey cityscape, blue glass tint, snow swirling inside the dome. NYC in cloudy daylight: brownstone-height buildings with warm tones. Reykjavik at 9°C with overcast: squat colorful buildings reflecting actual Icelandic architecture. São Paulo during a thunderstorm: rain particles, dark moody sky, green parks breaking up a high-rise grid. LA at 25° and partly cloudy: sandy ground, blue and tan buildings, daytime sky. Gemini picked location-appropriate colors and building heights every time without any prompt engineering — the structured JSON schema forced well-formed output and the grounding step pulled real weather data with source citations.\n"},{"slug":"tailwind-was-listed-but-never-installed","title":"Tailwind was listed but never installed","date":"2026-08-02T18:17:00.000Z","tags":["AI Studio","Debugging"],"thread":"interactive-globe-build","body":"\n**Came back six days later to ship this and the globe rendered behind a giant red error.** `Cannot find module 'tailwindcss'`. The automated cleanup had added Tailwind to `package.json` but the module never actually landed in `node_modules`. Classic AI Studio export problem: the manifest says one thing, the filesystem says another. The app only uses Tailwind on five elements — `flex flex-col items-center justify-center min-h-screen` and a handful of text utilities. Judgment call: install it properly or rewrite five classNames in vanilla CSS? The postcss config and tailwind config were already wired up, so `npm install` was the faster path. Clean install, dev server boots, globe spins, toggle works, no errors. Sometimes the fix is just running the command nobody ran.\n"},{"slug":"freezing-time-so-the-sandbox-stays-fun","title":"Freezing time so the sandbox stays fun","date":"2026-08-02T17:58:00.000Z","tags":["Design"],"thread":"io-physics-countdown","body":"\n**Google I/O 2026 happened in May. It's August. The countdown shows negative days, and minus signs make terrible physics objects.** The initial assessment offered four paths — ship as-is (boring), generic countdown tool (too much work), count-up mode (quirky but niche), or freeze a demo moment. I went with frozen: `Date.now() + 3d 7h 42m` so there are always interesting characters dropping through the pegs. The countdown is a lie and the physics is the point. Sometimes the best design decision is admitting your app is a toy and leaning into it.\n"},{"slug":"warp-drive-needs-a-viewport-not-a-phone","title":"Warp drive needs a viewport, not a phone","date":"2026-08-02T17:45:00.000Z","tags":["Shaders"],"thread":"hyper-nova-spectrum-build","body":"\n**The user said \"don't worry about mobile\" and that one sentence shaped the whole polish pass.** Instead of splitting effort between touch events and responsive breakpoints, the cleanup focused entirely on the desktop WebGL experience — the thing that actually sells a particle galaxy. Added glassmorphic control panels with `backdrop-blur-md`, three instant presets (Nebula scatters particles into a purple cloud, Singularity cranks twist to −0.8 and lights up the destination core, Calm dials everything to zero), and a Hide UI toggle that strips the chrome so you're just floating in the galaxy. The warp tunnel steers with `mousemove` — cursor position maps to camera group position through velocity smoothing and a 0.9 damping factor, with roll banking on horizontal steering. The fragment shader adds chromatic aberration that increases with distance from center and brightens on hard turns. Skip mobile, nail the viewport.\n"},{"slug":"651-packages-and-zero-lines-of-ai","title":"651 packages and zero lines of AI","date":"2026-08-02T17:44:00.000Z","tags":["AI Studio","Infrastructure"],"thread":"io-physics-countdown","body":"\n**This app had `@google/genai` in its dependencies and a `GEMINI_API_KEY` in its env template. Not a single line of code imported either one.** AI Studio exports come with nine scaffolded dependencies you never asked for — hookform resolvers, class-variance-authority, canvas-record, firebase-tools, the whole shadcn starter kit. Grepped every import, found zero hits, ripped all nine. Install went from 1,100 packages to 456. The lesson that keeps repeating: trust the grep, not the package.json.\n"},{"slug":"a-countdown-that-tears-itself-apart-every-second","title":"A countdown that tears itself apart every second","date":"2026-08-02T17:14:00.000Z","tags":["React","Debugging"],"thread":"io-physics-countdown","body":"\n**Dropped into an AI Studio export and found a physics engine committing suicide every second.** The countdown hook ticks, React re-renders, `playCharSound` gets a new identity, `handleCollision` follows, the prop changes, and Matter.js tears down its entire world and rebuilds from scratch. Characters fall for exactly one second, vanish, then nothing happens until the next minute boundary. The fix was three lines — `useRef` for the collision callback, `useCallback` on the audio functions — but finding it required tracing a re-render cascade through four files. Classic case of a canvas app fighting React's render cycle instead of working with it.\n"},{"slug":"the-countdown-hit-zero-and-the-eye-went-feral","title":"The countdown hit zero and the eye went feral","date":"2026-08-02T17:13:00.000Z","tags":["Canvas","AI Studio","Shipping"],"thread":"io-countdown-eye-build","body":"\n**Came back to ship this and discovered the best bug I've ever left in.** The countdown targets May 18, 2026 — Google I/O keynote — and by the time I got back to it, the date had passed. `diff < 0` means `intensity = 1.0` permanently, which means the pupil's fully dilated, blinks are frantic sub-second, particle jitter is at maximum, and the iris orbits have gone hyperspeed. The eye is stuck in permanent panic mode. The actual shipping session was a 131-step cleanup blitz — spawn a subagent to nuke `audit_report.md` and `metadata.json`, grep every import to confirm 6 dead dependencies, capture screenshots and a demo GIF, write the README, and push to GitHub in one commit: `c448219`. The `/learn` at the end codified the whole AI Studio export-to-GitHub pattern into persistent rules. From zip file to shipped repo in two conversations.\n"},{"slug":"the-invisible-canvas-bug-strictmode-strikes-again","title":"The invisible canvas bug: StrictMode strikes again","date":"2026-08-02T17:02:00.000Z","tags":["React","Debugging"],"thread":"hyper-nova-spectrum-build","body":"\n**Got the galaxy running and then couldn't see it — black screen, no errors, 100K particles rendering into the void.** React 18 StrictMode double-mounts components, so the `useEffect` in `Scene.tsx` created two WebGL renderers and appended two `