Building It

The Experiment

Six Degrees wasn't built the traditional way. It started as an experiment: could AI tools build a project that had lived in my head for years? Not a landing page or a to-do app, but something with real data, 3D rendering, force-directed physics, user accounts, and a database. Something I'd never built before and didn't know how to build.

The honest version: I didn't write this code by hand. I started with Google's AI Studio, describing what I wanted and iterating on the output. When the prototype hit the limits of what that tool could do (connecting to real APIs, setting up a database, deploying), I moved to Cursor with Claude, and later brought in Codex for systematic feature work. The entire project was an exercise in directing AI toward a creative vision rather than writing every line myself.

That distinction matters. The tools generated code. They didn't generate the concept of 28 relationship types, or the decision to use a star map metaphor, or the feeling that watching old cover art drift past a camera should feel like nostalgia. Those came from years of thinking about how games connect, and from working in the industry long enough to know that influence doesn't flow in straight lines.

Day One

November 24, 2025. Twelve commits. By midnight, the project had a React app, a static dataset of about 50 games, a 2D force-directed graph, search, filtering, a detail panel, and a relationship system with 15 types. App.tsx was 111 lines long.

That first version used react-force-graph-2d with a hardcoded JSON file of games and connections. No database. No API. Just a static bundle that rendered a flat network you could drag around. The relationship types were refined three times that same day as the vocabulary crystallized: influence, studio lineage, engine sharing, spiritual successors, mod origins, design antithesis.

By evening, a timeline component existed. An animated starfield background was running behind the graph. Pre-1980 game data had been added. The bones of every major feature were visible in that single day's work, even if nothing was connected to real data yet.

The Backend Earthquake

December 13. Eighteen commits in a single day. This was the moment the project stopped being a prototype.

The static JSON dataset was replaced with Supabase: PostgreSQL, auth, RPC endpoints for bounded per-year game loading with seeded random selection. The same day, Louvain clustering landed (community detection via graphology), cover art rendering went live with 446 game covers, and an audio controller appeared for ambient sound. Mobile interaction got its first polish pass.

One day later, December 14, IGDB metadata integration arrived. The relationship inference engine (buildGeneratedRelationships.ts) was born, generating edges from shared genre, platform, studio, and theme data. The curated relationship count of 15 types expanded to 28 as the system learned to infer connections from metadata overlap.

Going 3D

December 14 was also the day Three.js arrived. The 2D force graph was replaced with a full 3D viewport: instanced sphere rendering, d3-force-3d for physics, a debug panel for tuning gravity and repulsion in real time. App.tsx grew from 111 to 580 lines.

For two weeks, the 2D and 3D views coexisted as a toggle. Users could switch between a flat graph and the star map. The 2D code kept growing in parallel, reaching 1,073 lines before it was finally deleted on December 29. Fifteen days after 3D arrived, flat was gone. The project committed fully to the galaxy.

The Holiday Marathon

The commit history between December 20 and January 4 reads like someone who decided to ship a product over winter break.

December 20 through 21: a performance sprint. Bloom and glow effects. Instanced rendering optimization. Level-of-detail for cover art. WebXR/VR support as an experimental branch. Playwright end-to-end tests. Runtime drag benchmarks. The project hit the point where mid-tier devices started struggling, and the response was a focused two-day push on GPU efficiency.

December 22 through 26: the entire authentication stack. Landing page, login modals, PKCE auth flow, user collections, the invite system, Turnstile captcha, rate limiting, password recovery, admin panel, Steam account linking. Five days to go from "anonymous prototype" to "authenticated product with invite-only access."

Christmas Day, 2025: fifty commits. The single busiest day in the project's history. Auth stabilization, session handling, captcha hardening, user profile features. A marathon session that turned the authentication system from fragile to production-ready.

December 27 through 29: the pathfinder (breadth-first search for shortest influence chains), the first round of data deduplication tooling, and the decisive removal of the 2D rendering path. The project scope crystallized. It was a 3D galaxy with auth, collections, search, timeline playback, and a pathfinder. Not a diagram tool. Not a database viewer. A place.

Codex Enters

December 30. The git identity switches from personal to occ-matt. Thirty-seven feature branches with the codex/ prefix start appearing over the next twelve days. Each one is a clean, single-commit PR targeting a specific task: fix VR input, extend IGDB metadata ingestion, add role-aware people structures, investigate connection management.

The pattern was structured: Codex handled systematic implementation, bug fixing, and data pipeline extension. The branch naming tells the story: codex/fix-* for live issues, codex/extend-* for data architecture, codex/refine-* for polish passes. Each branch was a clear task assignment, shipped as a focused PR.

Meanwhile, on January 3, three planning documents appeared mid-sprint: a product review written from external perspectives, a phased rollout plan, and a ship list with specific targets (time-to-aha under 90 seconds, first meaningful render under 3 seconds, 30 FPS on mobile). The human was doing strategy while the AI did implementation. That division of labor felt natural. The AI was better at writing consistent code across dozens of small tasks. The human was better at asking "is this ready?" and knowing the answer.

The Human Moments

The git log is mostly clean commit messages. But scattered through the history are the moments that remind you a person was driving this, not a pipeline.

December 17: not sure what these changes are. An honest shrug, committed to the repo. Probably a merge that touched files unexpectedly.

January 9: brought back games.ts. Lowercase, informal. Something got deleted that shouldn't have been. The seed dataset, the original 50 games that started the whole project, accidentally removed during a cleanup pass. Restored quietly.

December 14: fix 3d view. An emergency commit with mangled filenames. The kind of thing you push when something broke and you need it working again before you can think about why.

The VR branch tells its own small story. Five dedicated WebXR pull requests between December 29 and January 4, each one fixing something the previous one broke. VR support was a secondary feature, but it kept demanding attention. Node dragging in virtual reality is harder than it sounds.

And the Steam integration saga: multiple fix commits within 24 hours spanning New Year's Eve and New Year's Day. A platform integration being debugged in real time, URL initialization order issues and import resolution bugs, while the rest of the world was counting down.

Burst Mode

The project was built in the gaps between a full-time job at a game studio, during a period of recurring illness. That context shapes everything about the commit history. The pattern isn't steady daily progress. It's silence, then an earthquake.

December 15 has one commit. December 16 has zero. Then three on the 17th, ramping back to six, eight, and then the 36-commit performance sprint on December 20. The gaps aren't laziness or lost motivation. They're the shape of building something ambitious on borrowed energy.

The total timeline, from first commit to the last feature PR, was 49 days. Inside that window: 560 commits, 28 Supabase migrations, 18 maintenance scripts, 28 relationship types, a full 3D rendering pipeline with bloom and instanced geometry, Louvain clustering with nebula overlays, WebXR support, PKCE authentication, Steam library import, timeline playback with cinematic mode, and an onboarding tour.

App.tsx grew from 111 lines to 6,053. The static dataset of 50 games became a dynamic pipeline pulling from IGDB with per-year bounded loading and seeded random selection. The 2D prototype became a 3D galaxy that runs at 30+ FPS on mobile and supports VR headsets.

None of it was planned as a seven-week sprint. It started as "let me see if AI can build the thing I've always wanted." The answer turned out to be: mostly yes, if you know exactly what you want and you're willing to steer hard. The code is generated. The vision isn't.