Pure Vibecoding Builds a 130+ Card Multiplayer CCG: Full AI Tech Stack Breakdown

When AI Becomes the Sole Developer

An indie developer who primarily works in mobile development shared a bold experiment on Reddit: building a fully playable multiplayer collectible card game (CCG) in the browser—Boomstick City—entirely through vibecoding (coding by "vibes," i.e., heavily relying on AI agents to handle the actual coding work).

Vibecoding is a new development paradigm that emerged in the developer community during 2024-2025, initially popularized by AI researchers like Andrej Karpathy. The core idea is that developers no longer write code line by line. Instead, they describe requirements in natural language, review AI-generated output, and guide the project direction at a high level. This is fundamentally different from traditional "pair programming"—in vibecoding, AI isn't the assistant; it's the primary code producer, while the human steps back into the role of requirements definer and quality gatekeeper. The rise of this paradigm is directly tied to the rapid advancement of code generation capabilities in large language models, especially the multi-file project comprehension and cross-module coordination abilities that models like Claude and GPT-4 demonstrated after 2024.

This isn't a toy-level demo. The game features 130+ cards, 4 factions, a complete multiplayer server, plus AI-generated card art and character voice acting. CCG (Collectible Card Game) is a genre with a long history, tracing back to 1993's Magic: The Gathering, with digital CCGs exploding in popularity after Hearthstone's massive success in 2014. Designing 130+ cards means accounting for each card's stats, effects, and interactions with every other card—development complexity far beyond what most people imagine. The author admitted this was his first truly substantial web project, and he wanted to find out "how far pure vibecoding could push a project." The answer: "Apparently, all the way."

Game Setting and Design

Boomstick City adopts a post-apocalyptic theme, but with a refreshingly grounded perspective—players represent organizations like "neighborhood HOAs" and "unionized demolition crews" struggling to survive after the end of the world. This darkly humorous setting injects fresh flavor into the traditional card game formula.

Gameplay uses a race-to-score system: the first player to accumulate 15 points wins. There are two ways to score—winning battles, or raiding the central objective when the enemy's field is clear. This design creates faster match pacing and provides two strategic paths: aggression and resource contention. Compared to the traditional CCG victory condition of "reduce your opponent's health to zero," the point-based system shortens individual match duration, making it better suited for fragmented browser gaming sessions. From a game design theory perspective, this "multiple paths to victory" mechanic increases strategic depth—players must dynamically switch between "focusing on combat scoring" and "waiting for opportunities to raid the central objective," creating more decision points and psychological mind games than a single win condition would. The author mentioned he originally designed different buff effects for each "zone" (playable battlefield), but quickly found this made the game confusing and hard to understand, so it was cut and saved for future iterations.

Full AI Tech Stack Breakdown: The Vibecoding Toolchain in Detail

What truly makes this project noteworthy is the nearly all-AI-driven tech stack behind it. The author listed the complete toolchain—essentially a comprehensive checklist of "AI productivity tools" for indie developers:

Core AI Coding Tools

• Claude Code: Served as the "driver" of the entire build process, leading the development flow;
• Opus 4.8: Handled the actual code writing;
• Fable: Used for code auditing and review, serving as the quality gatekeeper.

Claude Code is a command-line AI programming tool released by Anthropic in 2025, and it differs significantly from typical chat-based AI coding assistants. Claude Code can directly read and modify code in the local file system, understand the entire project's directory structure and inter-file dependencies, and autonomously plan and execute multi-step coding tasks through an agentic loop. An agentic loop refers to an AI system's ability to autonomously cycle through "think-act-observe" after receiving high-level instructions: analyze the current code state, plan the next operation, execute code modifications, observe results (such as compilation output or test results), then decide on subsequent actions based on observations. This loop enables AI to handle tasks far more complex than single-round Q&A. A developer can give a high-level instruction like "add a turn-based combat system to this card game," and Claude Code will independently analyze the existing code architecture, create necessary files, write implementation code, and run tests. This autonomy makes it the core engine of vibecoding.

This "primary coding model + auditing model" combination is worth examining. It reflects an emerging AI-assisted development paradigm: rather than having a single model handle everything end-to-end, an independent review step is introduced for cross-validation of code quality—essentially simulating the division between "development" and "code review" in human teams. The theoretical foundation of this strategy is that different models have different blind spots for different types of errors, and cross-validation significantly improves code reliability—similar to an AI implementation of software engineering's "four-eyes principle." In traditional software engineering, the four-eyes principle requires every piece of code to be reviewed by at least one non-author before merging into the main branch, with research showing this reduces defect escape rates by 60-90%. Applying the same concept to AI toolchains—using one independent model to review another model's output—theoretically captures the primary model's systematic biases and common error patterns.

Multiplayer Server and AI Content Generation

• Colyseus: Handles multiplayer server logic. This is a mature open-source multiplayer game framework and one of the few "non-AI" pieces of traditional infrastructure in the entire stack;
• GPT: Generated all 130+ card art images;
• ElevenLabs: Handled character voice acting.

Colyseus is an open-source multiplayer game server framework built on Node.js, specifically designed for real-time multiplayer games. It provides core features like Room management, State Synchronization, and message broadcasting, using a Schema-based serialization mechanism to minimize network bandwidth consumption. For turn-based games like CCGs, Colyseus's state synchronization mechanism is particularly well-suited—the server maintains the authoritative game state (such as both players' hands, field units, health values, etc.), while clients stay synchronized through incremental updates. This "authoritative server" architecture is a key anti-cheat design—all game logic judgments (like whether a card can be played, whether damage calculations are correct) execute server-side, while the client only handles display and input. Even if the client is tampered with, it cannot affect game outcomes. Choosing Colyseus over building a custom WebSocket server reflects that even in AI-dominated coding workflows, battle-tested mature frameworks remain the best choice for risk reduction.

ElevenLabs is one of the current leaders in AI voice synthesis, with its core technology being a Transformer-based text-to-speech (TTS) model capable of generating extremely realistic human voices with support for emotion control, speed adjustment, and multilingual switching. Traditional character voice acting requires hiring professional voice actors, renting recording studios, conducting multiple recording sessions, and post-processing—typically costing thousands to tens of thousands of dollars. ElevenLabs compresses this cost to near-negligible levels, enabling indie developers to give unique voice characteristics to every character in their game. More notably, AI voice acting also brings a qualitative change in iteration speed—if you later need to modify dialogue or add characters, traditional methods might require rebooking voice actors and scheduling recording sessions, while AI voicing only requires modifying text input to get new audio files in seconds.

A noteworthy detail: code, art, and voice acting—all three major content production pipelines—were handled entirely by AI. The author primarily played the role of "product manager" and "conductor." For a solo mobile developer, this workload would have been almost unimaginable in the past—traditionally, a CCG of similar scale would require at least four types of roles: programmer, artist, sound designer, and game designer, with team sizes typically of 5-10+ people and development timelines measured in years. Using Hearthstone as a reference, Blizzard invested a core team of approximately 15 people spending over two years on initial development. That a single indie developer achieved similar functional coverage using AI toolchains (though the level of polish isn't comparable) is itself an epochal signal.

The Capability Boundaries of Vibecoding: How Far Can AI Programming Go?

The most valuable aspect of this project isn't how polished the game is—it's that it provides a real data point for the question "how complex of a software product can AI independently complete?"

What Vibecoding Proved

A developer from outside the web domain, leveraging AI toolchains, independently completed and successfully launched a full product featuring real-time multiplayer synchronization, complex card logic, complete art and sound effects (www.BoomstickCity.com, playable without registration). This demonstrates that current AI agents can handle projects with genuine technical depth—not just CRUD apps or static pages. Real-time multiplayer sync involves network latency compensation, state consistency guarantees, and disconnection/reconnection—complex distributed systems problems. Card logic requires handling extensive conditional judgments, effect stacking, and priority resolution—areas that traditionally demand senior engineers spending significant time debugging.

Specifically, latency compensation is one of the trickiest problems in multiplayer gaming. When two players are on different continents, network round-trip time can exceed 200 milliseconds, and the system must ensure both sides see consistent game state without players feeling noticeable input lag. For turn-based games like CCGs, this problem is significantly simpler than in FPS games, but still requires correctly handling race conditions like "two players playing cards almost simultaneously." Effect stacking and priority resolution is CCG-specific complexity—when multiple card effects trigger simultaneously (e.g., "heal 1 HP when taking damage" and "deal equal damage to opponent when healing"), the system needs a clear and consistent resolution order, or it will produce logical contradictions or infinite loops.

What Vibecoding Exposed

A pain point the author repeatedly emphasized was card balancing. He said it "took a very long time" and specifically asked the community for balance feedback in his post. This precisely reveals vibecoding's boundaries: AI excels at rapidly generating functional code, but in areas requiring extensive iteration, real player data feedback, and "design feel," AI still falls short.

Card balance is difficult for AI to solve because it's fundamentally a multi-dimensional compound optimization problem. A card's "power level" doesn't exist in isolation—it depends on its combinatorial relationships with all other cards (synergies and counters), the current meta environment (strategies favored by the player population), and efficiency differences across players of different skill levels. Traditional CCGs like Magic: The Gathering and Hearthstone invested dozens of designers and years of accumulated data for continuous balance adjustment, and even then frequently needed emergency nerfs or card bans. This is fundamentally a domain that requires massive real-player behavioral data for effective optimization—pure theoretical reasoning and AI simulation cannot cover all extreme combinations human players will discover. With 130 cards as an example, just considering pairwise combinations yields over 8,000 possible interactions, and actual deck building involves selecting 20-40 cards with an astronomically large combination space. Even using AI-simulated matches to test balance, AI strategy exploration cannot fully represent human player creativity—human players often discover destructive combinations the designers never anticipated (commonly called "broken combos" or "infinite loops"), and these edge cases are precisely the most critical and hardest-to-predict parts of balance adjustment.

Balance is fundamentally a game design problem, not an engineering problem—the kind of problem that still heavily depends on human experiential judgment. The scrapped "zone-differentiated buffs" design is the same story—technically fully implementable, but it "quickly became confusing and hard to understand," ultimately removed due to experience and design considerations. AI can build complex systems, but the responsibility of judging whether a complex system is "fun" still falls on humans.

Implications for Indie Developers: The New AI Programming Workflow

Boomstick City is a case where the signal matters more than the product itself. It outlines a new indie development workflow:

1. Specialized division of labor across AI toolchains: No longer a single AI doing everything, but different models (Claude Code leading coding, Fable for auditing, GPT for art, ElevenLabs for voice) each handling their specialty. This multi-model collaboration pattern resembles the philosophy of microservice architecture—each AI tool focuses on what it does best, with the human developer serving as the "orchestration layer" to coordinate overall output. In the history of software architecture evolution, the transition from monoliths to microservices unleashed enormous development efficiency, and the same logic is replaying in AI toolchains: rather than expecting one "omnipotent AI," combining multiple specialized tools is more effective. This also means one of developers' core skills in the future will be "AI tool orchestration ability"—knowing which tool to use at which stage, and how to define interfaces and handoff standards between tools;

2. Traditional infrastructure remains essential: Mature frameworks like Colyseus still serve as the reliable foundation—AI hasn't replaced the entire engineering ecosystem. Network protocols, databases, deployment and operations, and other underlying infrastructure still rely on production-proven traditional solutions in the near term. This point deserves emphasis—AI-generated code still runs on real servers, transmits over real networks, and stores in real databases. The reliability and performance optimization at these infrastructure layers represent decades of accumulated software engineering achievement that AI code generation cannot bypass;

3. The human role migrates upward: Developers shift from "writing code" to "defining requirements, controlling experience, making design decisions"—especially in subjective domains like balance and gameplay fun. This trend is consistent with the historical evolution of the software industry—from machine code to assembly, from assembly to high-level languages like C/C++, from high-level languages to scripting languages and frameworks like Python/JavaScript, and now to AI agents. Each elevation in abstraction level pushes developers toward higher-level decision work. 1950s programmers needed to manage registers and memory addresses, 1990s programmers focused on algorithms and data structures, 2020s programmers make architecture decisions and system design choices, and AI-era developers may primarily need to make product decisions and user experience judgments.

The author also planted a community easter egg: entering the redemption code "REDDIT" in game settings unlocks an exclusive card called "The Red It"—this kind of community-facing operational awareness is another form of product intuition AI cannot yet replicate. It reflects deep understanding of user psychology and community culture—the ability to know "what will make a specific group feel surprised and valued" is essentially a form of social intelligence. The Reddit community has a strong sense of in-group identity, and an exclusive easter egg isn't just a marketing tactic but a signal saying "I'm one of you." This kind of socially-cognitive decision-making—understanding a specific group's cultural symbols, emotional triggers, and belonging needs—relies on deep understanding of human social dynamics and is one of the areas current AI is least capable in.

For developers watching AI programming capabilities from the sidelines, this case's conclusion might be: The barrier to technical implementation is being rapidly leveled by AI, while the value of product judgment and design taste is actually rising. When "can we build it" is no longer the question, "what should we build it into" becomes the only question that matters.