Fantopy AI: full record

It started wide. In the first week I built and deployed eight full Next.js mock apps in parallel, so the product's look was chosen from working answers rather than mood boards. The winning direction, Void, became spectator-ui-v2, a Vue frontend I built from scratch, with a 30-second request cache that cut about 85 API calls per navigation to near zero and a 29-device viewport wall to QA it on.

In April the real product turned out to be a different app: a React 19 codebase a teammate had started. I moved what transferred, kept the rest as reference, and took that frontend on, rebuilding it screen by screen: the squad command centre, fixtures, competitions, settings, scoring rules, the invite and creator flows, and an onboarding funnel where the conversation itself is the interface, with score pickers and take cards arriving as chat messages rather than forms.

There was no router in it. Three hand-rolled state machines handled routing, because the app was a phone frame with a funnel, an arena and a public watch surface, and a router would have added a dependency to solve a problem we did not have.

The public side, /view/<handle>, which I drove through the team's shared account, rendered the real screens read-only, so a shared link was the actual product rather than a marketing page of it.

Each pivot got a named language rather than a reskin: Void for the first spectator app, Aurora Glass Frost for the mobile era, then the cinematic jade language the shipped product wore. The last of these got ported back into the legacy Vue app at the end so the two frontends finally spoke the same way.

The motion is a system, not decoration. Twelve named patterns, documented so someone else could extend them: a pitch that boots like stadium floodlights coming up rather than fading in, idle loops on co-prime durations so nothing ever pulses in unison, a chat sheet whose outline and frosted backdrop are the same computed path so they read as one physical object.

The squad pitch was a real 3D surface: a CSS-transformed slab with player markers projected onto it in JavaScript, so the chips stayed crisp while the board sat in perspective.

Performance counted as design too. On a card-swipe demo built for a client pitch, I ran two AI investigators independently, ruled offenders out by elimination, and rebuilt rendering down to about five paint surfaces: 11 to 13ms frames against a 16.6ms budget. Then I audited what visual quality the optimisation had cost, and restored it.

It started as friction. I was watching real matches in the app, filing bugs from what I saw, and fixing them one at a time. Within two days I had specified a watcher that could collect assigned issues and start agents on them. Within a month it was Fantopy Orchestrator, a factory: intake, triage, routing, workers in isolated worktrees, verifiers, reviewers, and human-only merge authority.

Its autonomy was bounded on purpose. It only ever opened draft pull requests and never merged one. Anything touching security, auth, payments or secrets, and any visual change, was routed to a human with the reason written on the issue, instead of being forced through an agent patch loop.

The hard part was not making it run. It was making it honest. Crash-safe atomic ledger writes. Race-correct file locking. A replay harness that turns the ledger into a labelled evaluation set. A verification gate designed so 'verified' cannot be claimed without evidence. And a convergence gate on the retry loop, added because I noticed the retries were not trending toward correct; they were just repeating.

Late in its life I made it engine-agnostic, so the same job could run on either of two model providers, with a capacity gauge and a circuit breaker deciding which.

Before letting fantasy launch, I drove a full knockout simulation through the real production primitives and independently recomputed every score rather than trusting the engine that produced them. Forty of forty agent-rounds reconciled. It also surfaced a bug where teams eliminated on penalties were still advancing.

The method became a habit and then a doctrine: never let the actor grade its own work. I applied it to my own systems too, running an adversarial critic over my own orchestrator, and later over my own record of this job.

The clearest single catch had nothing to do with tooling. I looked at a leaderboard, thought the midfielder scores were absurd, and went into the stat provider's type dictionary until I found that the ID we were reading meant total passes, not key passes. One constant, inflating every midfielder and forward on the platform. The check had to establish what the provider's field meant as well as whether the calculation was correct.

At the end, when the founder asked for the old paid agent product back, I brought the devnet deployment back, proved the payout pipeline 17 of 17 on public devnet, then brute-forced all twenty contest permutations with 157 chain-asserted checks. It caught five bugs: four fixed inline, the fifth closed as a named architecture decision.

The largest piece was collapsing 'gameweek' into a universal contest identity across sixty-nine files, so the codebase stopped assuming one sport with one shape. It is the least visible work I did and close to the most important: every league feature since sits on it. I argued for the time it took, during a stretch when shipping visible features was the easier choice.

After the tournament I built the next step, a declared product-by-league grid: capability flags, per-league hooks, season transfer accounting verified 72 of 72 end to end, and a fix for a race where two leagues syncing at once could contaminate each other's data. It was still in an open pull request when I left.

Alongside that, the unglamorous production work: penalty shootouts that were never being ingested, knockout matches stuck live forever, scoring writes that timed out on large competitions, and 551 rows of production data healed by hand and verified.

Launch night was one overnight push: thirteen pull requests, eight root causes, and a bug where a user's squad appeared to change by itself, which turned out to be the browser's stored copy fighting the server's. I wrote the architecture document for the root cause the same night, shipped the fix, and promoted it to production myself.

Then two weeks of stabilisation with users live: a shared query cache so navigation stopped resetting screens to skeletons, a tournament clock, captain multipliers, and a lenient knockout law so mid-round joiners were scored fairly. When a promote carried risk, I read the deployed bundle back rather than trusting the pipeline.

As the tournament ended and access to the match data was running out, I made the era recoverable: the finished World Cup kept bootable, every local database dumped, the full pull-request history exported, and restore instructions written.

My last two days moved the live product onto the next Premier League season. I backed up production, promoted 85 commits, deployed by hand while CI was down, seeded the new season, and retired the World Cup without deleting anyone's data. A verification pass found six places where code named a season instead of looking it up, one of them mixing stats across seasons. Then I handed it over: one verified baseline on both servers, a rollback tag, three checksummed backups, and a handover written so the founder's own agent could act on it.

First I built two films in code, one in Remotion and one as a GSAP composition rendered through parallel workers, then rejected both approaches for the launch cut, because having shipped with them I could see the output felt like slides.

What replaced it was an AI video pipeline with a rule: use AI for motion, not for redesign. Every clip anchored to an approved still frame. Titles and logos kept deliberately out of the model's reach so the words could not mutate. Thirteen storyboard versions before one earned the cut, with every rejection kept on disk in a labelled folder saying why.

Then the parts nobody sees: a generation script that refuses to run without an explicit flag so a stray command cannot spend credits, an assembler that degrades to still frames when a clip is missing, and a marketing foundation with a rights taxonomy for every route a piece of footage can legally arrive by.