Hoe ik Quads bouwde, een mobiel bordspel, met Claude — van een hackathon van 2 uur tot de App Store

Inhoudsopgave

Bijgewerkt in juli 2026.

Kort samengevat: Quads is een mobiel bordspel — een strakke interpretatie van het klassieke abstracte spel Quarto — dat begon als een hackathon van 2 uur met een vriend in Colombia en werd gelanceerd in de app stores. Dit is de volledig-open versie van hoe ik met Claude bouw: parallelle agent-worktrees, een echte (niet-LLM) game-AI, offline-first ontwerp, en de specifieke valkuilen die me uren kostten.

[Blik van de operator] Ik run meer dan 30 productie-agents verspreid over een consultingmerk en Pickleland, mijn pickleball-faciliteit in de regio Austin. Het meeste van wat ik bouw is serieuze bedrijfssoftware waarbij ik het draaiboek privé houd. Quads is het tegenovergestelde — een leuk zijproject dat ik je van boven tot onder kan laten zien. Als je precies wilt zien hoe ik met Claude werk, zonder dat er iets is weggeslepen, dan is dit het bericht. Je vindt het spel op playquads.com.

Het begon als een hackathon van 2 uur in Colombia

De oorsprong is bijna gênant nonchalant. Ik was op reis in Colombia, en een vriend en ik gaven onszelf een hackathon van 2 uur: kies iets kleins, bouw het met AI, kijk hoe ver we komen. We kwamen uit bij Quarto — een prachtig klein abstract strategiespel dat makkelijk te leren is en verrassend diep. Twee uur later hadden we een speelbaar prototype, en het idee was te goed om op een laptop achter te laten.

Wat begon als een uitdaging met tijdslimiet werd een echte, gelanceerde mobiele app op iOS en Android. Die boog — grap-prototype tot storevermelding — is de hele reden waarom ik denk dat dit project het schrijven waard is. De afstand tussen “leuk idee” en “iets dat vreemden kunnen downloaden” is ingestort, en Quads is een strakke case study van hoe.

Eerst een korte uitweiding over de naam. Het spel is een herimplementatie van Quarto, wat een gemerkt spel is in eigendom van Gigamic. Dus de allereerste niet-code-beslissing was om het niet Quarto te noemen op enige plek waar een klant het zou zien. Het ging van Quarto (de mechaniek) via een paar tussentijdse namen naar Quads — een naam die ik zelf mag gebruiken. Als je een klassieker herimplementeert, regel de merkkwestie dan uit voordat je verliefd wordt op een naam.

Wat Quads eigenlijk is

Voor de niet-ingewijden: Quads wordt gespeeld op een 4×4-bord met 16 unieke stukken. Elk stuk heeft vier binaire eigenschappen — lang of kort, donker of licht, vierkant of rond, massief of hol — en de 16 stukken dekken elke mogelijke combinatie precies één keer. Je wint door een lijn van vier stukken te voltooien die één willekeurige eigenschap delen.

De draai die het briljant maakt: je kiest niet het stuk dat je plaatst. Je tegenstander overhandigt het je. Dan overhandig jij hun stuk. Dus elke beurt is een dubbele klem — je probeert het stuk dat je kreeg te plaatsen zonder een winst op te zetten, terwijl je een stuk kiest om te geven dat je tegenstander het spel niet in handen geeft. Het is elegant en echt lastig.

De app biedt vier manieren om te spelen, allemaal volledig offline: tegen de computer over vijf moeilijkheidsniveaus, doorgeef-en-speel op één apparaat, een dagelijkse puzzel, en een asynchrone “daag een vriend uit”-modus. Geen account, geen server, geen login. Die offline-first beslissing stuurde veel van de engineering, en het is een groot deel van waarom een solo-build behapbaar was.

De spellogica: een hele set regels die uit bitrekenkunde rolt

Dit is mijn favoriete deel, want het is het soort ding dat bevredigend is, of AI het nu schreef of niet.

Elk van de 16 stukken is gewoon een geheel getal van 0 tot 15. Elk van de vier bits is één eigenschap. Dat is het — de hele stukkenset is de getallen 0–15, want vier bits geven je precies 16 combinaties.

Winstdetectie wordt dan bijna triviaal. Voor elke lijn van vier stukken houd je twee lopende accumulatoren bij: de bits die 1 zijn in elk stuk, en de bits die 0 zijn in elk stuk. Als een van beide accumulatoren niet-nul is na alle vier, zijn de stukken het eens over ten minste één eigenschap — dat is een winst. De hele set regels valt terug op een paar bitsgewijze AND-operaties.

Omdat de logica pure functies over gehele getallen is — geen framework, geen UI, geen state — is het direct unit-testbaar, en het is triviaal uit te breiden. Quads biedt zelfs een huisregelvariant waarin de negen 2×2-vierkanten ook als winnende vormen tellen, wat een toevoeging van twee regels is bovenop dezelfde bittruc. Wanneer jij en een AI-partner de kernlogica zo schoon houden, is een functie toevoegen een genoegen in plaats van een risico.

De AI-tegenstander is geen LLM (en dat is de juiste keuze)

Hier is een leermoment dat me aan het hart gaat: niet elke “AI” hoort een groot taalmodel te zijn.

De Quads-tegenstander is pure klassieke game-AI, en dat hoort ook zo. Bij elke beurt maakt hij twee beslissingen — waar het stuk te plaatsen dat hij kreeg, en welk stuk terug te geven — en de moeilijkheidsgraad schaalt hoe hard hij nadenkt:

• Beginner speelt in wezen willekeurig en zal je de winst overhandigen.
• De middelste niveaus voegen heuristieken toe: pak een directe winst als die bestaat, en vermijd het weggeven van een stuk waarmee de tegenstander kan winnen, met voorkeur voor het stuk dat de minste toekomstige dreigingen bewapent.
• Meester en Grootmeester draaien een begrensde negamax-zoektocht — echte spelboom-zoektocht — maar met een hard knooppuntbudget, zodat een zet nooit de hoofdthread van de telefoon kan laten hangen. Vroeg in het spel, waar perfect zoeken onhaalbaar is, valt het terug op snelle heuristieken; laat in het spel, waar de boom klein genoeg is, zoekt het echt.

Twee dingen die het waard zijn om hiervan te stelen. Ten eerste zou een taalmodel hier slechter zijn — langzamer, duurder, niet-deterministisch en verslaanbaar — dan vijftig regels negamax. Stem de tool af op het probleem. Ten tweede is het knooppuntbudget de echte engineering: op een mobiel apparaat is “correct maar hangt af en toe vier seconden” een mislukte functie. Het zoeken begrenzen zodat een zet altijd snel is, ook al is die af en toe suboptimaal, is het verschil tussen een speeltje en een product. Weten wanneer je naar een LLM moet grijpen is hetzelfde oordeel dat ik toepas op elke automatisering — het is de kern van hoe ik bepaal of een AI-build de moeite waard is.

Hoe ik Claude daadwerkelijk draai: parallelle agents in worktrees

Nu het deel dat ik privé houd op mijn grotere producten, maar je hier volledig kan laten zien.

Ik bouw niet met één Claude-sessie tegelijk. Ik draai er meerdere parallel, elk in zijn eigen git worktree op zijn eigen branch. Eén agent voegt internationalisatie toe, een ander bouwt het dagelijkse-puzzel-systeem, een ander doet kleurenblindmodus, weer een ander sluit geluid aan — elk geïsoleerd in zijn eigen werkkopie zodat ze elkaar niet kunnen overschrijven, en elk wordt teruggevoegd wanneer het groen is. De git-geschiedenis van Quads is een muur van Merge branch 'worktree-agent-…'-commits, wat precies is hoe die workflow er van buitenaf uitziet.

De reden dat worktrees ertoe doen is eenvoudig: parallelle agents die dezelfde werkmap bewerken lopen elkaar meteen voor de voeten. Geef elk een geïsoleerde checkout en je kunt werkelijk vier functies tegelijk in aanbouw hebben, en ze dan samenvoegen zoals elke andere branch. Het is de enige verandering met de hoogste hefboomwerking in hoe ik werk — ik ging van één gesprek, één functie, naar een kleine vloot.

Wil je de discipline achter de prompts waarop die agents draaien, dan is het dezelfde die ik beschrijf in hoe je systeemprompts voor AI-agents schrijft die niet falen in productie: de hefboom zit in heldere, actuele specificaties, niet in slimme formuleringen.

De valkuil die me een uur kostte (zodat het jou er geen kost)

Elk project leert je één domme, dure les. Bij Quads was het deze: de previewtool toont niet altijd de branch waarvan je denkt dat hij hem toont.

Wanneer je meerdere agents in meerdere worktrees draait en hun werk previewt, kan de preview vanuit een andere map starten dan die waar je huidige sessie in zit — dus je maakt een screenshot van de app, ziet geen van je wijzigingen, en begint een “ontbrekende” UI te debuggen die nooit ontbrak. De functie was prima; de preview wees naar de verkeerde checkout. Ik verloor echte tijd hieraan voordat ik doorhad wat er gebeurde, en ik schreef het op in de eigen notities van het project zodat de toekomstige ik (en elke agent aan wie ik de repo overhandig) het previewdoel controleert voordat er spookbugs worden gedebugd.

De verwante valkuil: het configuratiebestand dat die previews definieert wordt gedeeld over parallelle sessies, dus twee agents die het tegelijk bewerken kunnen stilletjes elkaars invoer overschrijven. Als je een vloot gaat draaien, behandel gedeelde configuratie dan als een betwiste bron — het bijt je precies één keer, en daarna nooit meer als je de les opschrijft.

Die gewoonte — elke moeizaam verworven valkuil vastleggen in een duurzaam bestand dat de volgende sessie zal lezen — is de stille ruggengraat van bouwen met AI op elke schaal. Context verdampt tussen sessies; opgeschreven lessen niet.

De offline-first trucs waar ik trots op ben

Omdat Quads geen backend heeft, hadden een paar problemen slimme, serverloze antwoorden nodig:

• De dagelijkse puzzel wordt deterministisch gekozen op basis van de lokale dag van het jaar, zodat elke speler wereldwijd dezelfde puzzel krijgt zonder enige servercoördinatie. (Bonusles: ik lanceerde, en repareerde toen meteen, een zomertijd-één-verschil-fout in die datumrekenkunde. Datums zijn altijd lastiger dan ze eruitzien.)
• “Daag een vriend uit” codeert een puzzel in een korte tekstcode — zoiets als QC1-01-03-3 — bewaakt door een checksum zodat een typfout geen geldige-maar-verkeerde uitdaging kan opleveren. Je vriend typt hem in hun eigen kopie van de app en speelt precies dezelfde stelling, volledig offline. Geen accounts, geen matchmaking, geen server.
• Rijke linkvoorbeelden zijn de ene plek waar ik wél een klein beetje servercode gebruikte. Wanneer je een uitdagingslink deelt, rendert een enkele Cloudflare Pages Function per-code Open Graph-tags zodat de link mooi uitvouwt in iMessage of WhatsApp. Sociale crawlers draaien geen JavaScript, dus een client-gerenderd voorbeeld zou er voor elke link identiek uitzien — één kleine function lost dat op zonder een echte backend nodig te hebben.

Geen van deze is lastig zodra je ze doorziet, maar elk ervan is een plek waar het luie antwoord is “start een server en een database,” en het betere antwoord is “doe het slimme offline ding.” Een backend volledig vermijden is waarom één persoon dit kon lanceren en onderhouden.

Van hackathon tot storevermelding

De laatste etappe — het deel dat niemand je vertelt over een “project van 2 uur” — is alles tussen “het werkt op mijn telefoon” en “vreemden kunnen het downloaden.” Internationalisatie over acht talen in één keer. Storeteksten die nooit de gemerkte naam gebruiken. App-store buildgereedschap, versiebeheer, en de platformspecifieke rechtenopschoning die voorkomt dat een storebeoordeling je terugstuurt. Dit is onglamoureus, en het is waar veel zijprojecten stilletjes sterven.

Het met Claude doen maakte de checklist niet korter, maar het maakte elk item goedkoop genoeg dat ik het daadwerkelijk afmaakte. Dat is het echte verhaal van Quads: niet dat AI een bordspel schreef — genoeg mensen kunnen er een prototypen — maar dat het de kosten van de laatste loodjes genoeg verlaagde dat een hackathon-grap een gelanceerd product werd.

Als je een klein idee hebt waar je op zit te broeden, dan is dat mijn hele pleidooi. Begin met de versie van 2 uur. Je zult verbaasd zijn hoe dichtbij de finishlijn is gekomen. En als je wilt zien hoe ver deze zelfde werkwijze op de schaal reikt, ik nam hem helemaal mee tot een volledige multi-tenant SaaS — hoe ik Courtlines, een platform voor clubbeheer, met Claude bouwde.

Speel Quads op playquads.com.

Veelgestelde vragen

Wat is Quads?

Quads is een mobiel bordspel voor iOS en Android — een strakke herimplementatie van het klassieke abstracte strategiespel Quarto. Je speelt op een 4×4-bord met 16 unieke stukken, en de draai is dat je tegenstander het stuk kiest dat je moet plaatsen. Het is gratis te spelen met modi voor solo, doorgeef-en-speel, een dagelijkse puzzel, en asynchrone uitdagingen. Vind het op playquads.com.

Heeft Claude het hele spel geschreven?

Claude schreef de grote meerderheid van de code, werkend vanuit het ontwerp en de beslissingen die ik bezit. Ik draaide meerdere Claude-sessies parallel, elk in zijn eigen git worktree, die verschillende functies bouwden die ik samenvoegde. De spellogica, de AI-tegenstander, internationalisatie, geluiden en het puzzelsysteem werden grotendeels op deze manier gebouwd en door mij beoordeeld.

Wordt de AI-tegenstander in het spel aangedreven door een LLM?

Nee — en dat bewust. De tegenstander gebruikt klassieke game-AI: heuristieken op lagere moeilijkheidsgraden en een begrensde negamax-zoektocht in de hoogste niveaus, met een hard knooppuntbudget zodat een zet het apparaat nooit laat hangen. Een taalmodel zou langzamer, duurder en zwakker zijn voor deze taak. Het juiste soort AI kiezen voor het probleem doet er meer toe dan altijd naar het grootste model grijpen.

Hoe lang duurde het om Quads te bouwen?

Het eerste speelbare prototype kwam voort uit een hackathon van 2 uur met een vriend tijdens een reis naar Colombia. Dat prototype omzetten in een gepolijste, lanceerbare app in beide app stores — met internationalisatie, een echte AI-tegenstander, offline uitdagingen en storenaleving — kostte aanzienlijk langer, maar elke afzonderlijke stap was goedkoop genoeg met AI dat het project daadwerkelijk de finishlijn bereikte.

Wat is de grootste les van het bouwen van Quads met Claude?

Twee dingen. Ten eerste, draai agents in geïsoleerde git worktrees zodat je meerdere functies parallel kunt bouwen zonder dat ze elkaar overschrijven. Ten tweede, schrijf elke valkuil op in een duurzaam bestand dat de volgende sessie zal lezen — context verdampt tussen sessies, maar opgeschreven lessen stapelen zich op. Voor het grotere plaatje van deze werkwijze, zie hoe ik Courtlines met Claude bouwde.