Sidefire: A Million Requests in Fifteen Minutes
Two Versions, Two Stories
Sidefire has two lives. Version 1 is a group chat app that works the way group chat should - no app store, no email signup, just your phone number. It still runs. It works fine.
Version 2 is a cautionary tale about hubris, AI development teams, and what happens when a Zustand selector goes rogue.
Both versions taught us something essential.
Version 1: Edge-Native Chat
The original Sidefire proved that a complete real-time messaging platform could run entirely on Cloudflare’s edge with zero traditional server infrastructure. WebSocket rooms, image sharing, push notifications, phone number auth - the full feature set. The kind of thing that would have required a fleet of servers five years ago, running on Workers and Durable Objects.
It was also the project where we started thinking seriously about native mobile. A companion iOS app in Swift explored what a proper native Sidefire client could feel like beyond the PWA.
Version 2: The AI Team Experiment
With v1 stable, the question became: could an entire rewrite be built by AI agents? Not one agent coding sequentially, but a team - Claude Opus as the architect, multiple Sonnet agents working in parallel as developers in separate VS Code instances.
Over 72 hours, the team produced 56 API endpoints, 458 tests, 31 React components, 13 database tables, and 101 commits. The parallelism model was elegant: file ownership as the concurrency primitive. No two agents touched the same file. Branches merged cleanly. Tests passed. Everything looked perfect.
Then we pushed to staging.
The problem wasn’t any single bug - it was the interaction between components that had been built in isolation. Each agent’s code was correct in its own context. Together, they created feedback loops that no one had anticipated because no one agent had the full picture.
The Twelve Lessons
The failure produced twelve documented lessons. The most important:
Integration testing is the bottleneck. Unit tests per-agent were comprehensive. But the integration surface - how components interact at runtime - was barely tested. AI agents are excellent at testing their own code. They’re terrible at anticipating how their code interacts with someone else’s.
File ownership ≠ feature ownership. A WebSocket handler and a state management hook don’t share files, but they share a contract. That contract was implicit.
The human has to be the architect. Claude Opus as architect worked for high-level decisions. It didn’t work for the unglamorous detail work: “what happens when the WebSocket reconnects while a selector is mid-update?”
Why It Mattered
Every methodology we use now - the spec-driven approach, the single-agent-per-session model, the emphasis on CI/CD feedback loops - was born from Sidefire v2’s failure.
Boopadoop was built in one afternoon using the lessons from three days of Sidefire chaos. That’s not a coincidence.
The Throughline
Sidefire is the failure that made everything after it possible. The twelve lessons became the methodology. The methodology built Boopadoop in an afternoon. The instinct to document what went wrong - honestly, in detail - turned a $200 Cloudflare bill into the most valuable education we’ve gotten from a side project.
Current Status
v1 still runs at old.sidefire.net. The memorial lives at sidefire.net - a snarky landing page for a project declared unsalvageable. Not because the code couldn’t be fixed, but because the development model had produced a codebase no one could reason about.