Georgie Rocky ▌

The problem: Existing tools choked at 500 annotations/hour. I needed 2,400. Every frame mattered when you're labeling training data for 8 hours straight.

My approach: Threw out React on day 3. Canvas-based renderer, manual DOM patching, Web Workers for everything that wasn't render-critical. Treat the DOM like it's expensive—because it is. Memory pooling, object reuse, the kind of obsessive optimization that makes other devs uncomfortable.

Built at 2 AM during a deadline crunch. Third iteration. First two used virtual scrolling libraries that fought me. Third one I wrote the scroller in 200 lines and it was 4x faster. Lesson: when performance matters, abstraction is the enemy.

Now: Processes 2M+ annotations daily across 12 annotators. Peak: 2,847 annotations in a single hour. Zero dropped frames on a 2019 MacBook Air. The secret isn't magic—it's saying no to everything that isn't essential.

The problem: Portfolio sites look the same. Template grids, fade-ins, the same three.js boilerplate. I wanted something that felt like flipping through a contact sheet in a darkroom.

My approach: No external libraries. Custom WebGL2 renderer in 14KB gzipped. Procedural film grain, chromatic aberration, scanline simulation— all in shaders. The images aren't loaded; they're streamed as compressed textures and decompressed in the GPU. Built the texture atlas packer myself because existing tools were too slow.

Process: Started with a film emulation shader I wrote at 3 AM. Realized I could build an entire gallery around the aesthetic. Spent two weeks hand-tuning the film response curves to match Kodak Portra 400. Yes, I'm that person.

Result: 60fps on iPhone 12. 14KB total bundle. Looks like you're viewing 35mm scans through a loupe. No JavaScript framework could do this. Sometimes the right tool is no tool at all.

The problem: Writing evaluation rubrics for AI training data takes 45 minutes per task. It's repetitive, it's boring, and humans are terrible at being consistent evaluators.

My approach: Built a system that generates rubrics from examples. Give it 5 good/bad pairs, it extracts the criteria, builds a rubric, then validates itself by scoring the examples. If it disagrees with human labels, it iterates. Meta-evaluation loop. Takes ~8 minutes end-to-end.

Built during: A particularly tedious annotation sprint. I was writing my 12th rubric of the day and thought "I could automate this, or I could keep suffering." Chose the first option. Three days later, the tool was generating better rubrics than I was.

Now using it for all annotation work. It doesn't replace judgment— it operationalizes it. When the LLM disagrees with me, I learn something about my own biases. Sometimes the machine is right. That's... humbling.

The problem: Annotation work happens on trains, planes, and places with spotty wifi. Central servers mean work stops when the connection drops. Unacceptable.

My approach: Built a P2P sync layer using CRDTs. Each node is a full SQLite database that syncs peer-to-peer via WebRTC. Conflict resolution handled automatically. Go offline for 3 days, come back online, and everything merges cleanly. No central server required, though you can run one if you want.

Iteration 1 used Operational Transforms. It was a nightmare. Switched to CRDTs after reading Martin Kleppmann's papers at 1 AM. Rewrote the whole sync layer in a weekend. Best decision I made on that project.

Currently: 47 nodes in production. Longest offline stretch: 11 days in rural Montana. Synced 14,000 annotations on reconnect with zero conflicts. The system works because I designed it for my actual life, not an idealized one.

The problem: Browser terminals die at ~10,000 lines. DOM nodes multiply, GC kicks in, everything stutters. I needed to render 500,000 lines of logs at 60fps. xterm.js couldn't do it. Neither could any terminal I tested.

My approach: Abandoned the DOM entirely. WebGL renderer, glyph atlas, text shaped in Rust and compiled to WASM. The entire terminal is one canvas element. Scrolling is just changing a uniform. Viewport culling happens on the GPU. Result: constant-time rendering regardless of buffer size.

Built in: Two furious weeks after watching a data pipeline dump 200k lines and bringing the browser to its knees. The Rust/WASM bridge fought me for three days. Almost gave up. Didn't. Worth it.

Now handling 500,000+ lines at locked 60fps on integrated graphics. Memory usage: flat. No DOM thrashing. The cursor blinks at exactly 530ms intervals, matching real VT100 behavior. Because details matter when you live in a terminal.

The problem: My notes are a graph, but all the tools show them as lists. I wanted to see the connections—the way ideas cluster, the paths between concepts, the shape of my own thinking.

My approach: Force-directed graph in WASM. Physics simulation runs at 120fps regardless of node count. Implemented Barnes-Hut optimization so it's O(n log n) instead of O(n²). Can handle 10,000 nodes smoothly. The layout algorithm is based on how I actually think: related ideas attract, unrelated ones repel.

Built: Over a month of evenings. Started as a way to visualize my annotation knowledge graph. Realized it was more useful as a thinking tool. Now I use it to find connections I wouldn't have seen otherwise. Graph as mirror.

Currently: 2,847 nodes, 8,192 edges. Longest path: 17 hops from "calculus" to "film grain shaders" (through linear algebra, optimization, and a detour into color theory). The graph knows me better than I know myself.