Retro-Spiel mit Claude Code bauen: Web, iOS, Android
Ein Spiel im Stil der C64-Klassiker mit Claude Code bauen: Stack, Prompts, Touch, Sound, Tests und Release für Browser, iOS, Android und Steam.
Von Nathan Base
Die großen Klassiker auf dem C64 waren erstaunlich einfach gebaut: ein Raster aus Kacheln, ein paar Regeln, ein Soundchip mit drei Stimmen. Genau deshalb eignen sie sich heute perfekt als Vorlage für ein eigenes Spiel, das Du mit Claude Code an ein paar Abenden baust und das danach im Browser, als App auf iPhone und Android und auf dem Desktop läuft. Dieser Guide führt Dich an einem vollständigen Beispiel durch alle Schritte: vom Spielkonzept über Grafik, Musik und Touch-Steuerung bis zum Release auf itch.io, in den App Stores und auf Steam. Das Budget dafür liegt bei null Euro, solange Du nur im Browser veröffentlichst.
Das Beispielspiel heißt Kristallstollen und ist ein Spiel im Genre von Boulder Dash, das 1984 bei First Star Software erschien: Du gräbst Dich durch Erde, sammelst Kristalle, weichst fallenden Felsen aus und lockst Gegner unter Steine. Ich habe es beim Schreiben dieses Artikels genau nach den hier beschriebenen Schritten gebaut und getestet, mit Node.js 24, Vite 8.3, TypeScript 7, Vitest 5.1 und Capacitor 8.6 auf macOS. Die iOS-App habe ich mit Xcode 26 für den Simulator kompiliert, das Android-Projekt angelegt, aber mangels Android-SDK auf dem Testrechner nicht selbst gebaut. Wo ein Schritt nur nach der offiziellen Doku beschrieben ist, steht das dabei.
Was am Ende herauskommt
Kristallstollen ist kein Prototyp, sondern ein komplettes kleines Spiel:
- drei Level mit 40 x 22 Kacheln, scrollender Kamera, Zeitlimit, Punkten und drei Leben,
- Schwerkraft für Felsen und Kristalle, die von runden Objekten abrollen, schiebbare Felsen und Gegner, die an Wänden entlangkriechen und sich in Kristalle verwandeln, wenn ein Felsen sie trifft,
- Pixel-Art in einer C64-artigen 16-Farben-Palette, komplett im Code definiert, ohne eine einzige Bilddatei,
- Soundeffekte und eine Titelmusik mit Bass, Arpeggio und Melodie, live erzeugt über die Web Audio API,
- Steuerung per Tastatur, Gamepad und Touch-Steuerkreuz, mit eigener Anordnung für Hoch- und Querformat,
- Bildschirmwackeln, Partikel, Lichtblitz und eine dezente Röhrenmonitor-Optik,
- Offline-Fähigkeit als installierbare Web-App, Highscore-Speicher und Vibration in der nativen App,
- 17 automatische Tests, darunter ein Bot, der jedes Level mit der echten Spiellogik durchspielt.
Der gesamte Spielcode ist gepackt keine 13 KB groß, der fertige Build mit Icons und Service Worker rund 100 KB. Zum Vergleich: Das Titelbild dieses Artikels ist größer.
Vorlage ja, Kopie nein
Bevor es losgeht, eine Grenze, die Du kennen solltest. Die Spielidee und die Spielmechanik sind nicht urheberrechtlich geschützt, das hält zum Beispiel das US Copyright Office auf seiner Seite zu Spielen ausdrücklich fest. Graben, Kristalle sammeln und Felsen fallen lassen darf also jeder. Geschützt sind dagegen der konkrete Ausdruck: Grafiken, Musik, Level-Layouts, Texte, Figuren, und über das Markenrecht oft auch der Name. Ein Spiel namens „Boulder Dash“ mit nachgebauten Original-Levels und der Original-Melodie ist deshalb tabu, auch wenn es nur „for fun“ auf itch.io landet.
Die Regel für dieses Projekt lautet deshalb: Mechanik vom Vorbild, alles andere selbst gemacht. Eigener Name, eigene Sprites, eigene Levels, eigene Musik. Das macht das Ergebnis nebenbei auch interessanter, weil es nach Dir aussieht und nicht nach einer Kopie.
Der Stack: Web-Technik statt Game-Engine
Für ein Spiel, das überall laufen soll, gibt es vier realistische Wege. Die Tabelle zeigt, wie sie sich für ein kleines 2D-Projekt mit Claude Code schlagen.
| Vite + TypeScript + Canvas | Phaser 4 | Godot 4.7 | Unity | |
|---|---|---|---|---|
| Browser | nativ, winziger Build | nativ | WebAssembly-Export, mehrere MB | WebGL-Export, groß |
| iOS und Android | per Capacitor | per Capacitor | eigener Export | eigener Export |
| Desktop und Steam | per Electron oder Tauri | per Electron oder Tauri | eigener Export | eigener Export |
| Wie gut kennt Claude es? | sehr gut, Web-Standards | gut, aber oft noch Phaser 3 | gut | gut |
| Automatisch testbar | Vitest, Playwright | Vitest, Playwright | eingeschränkt | eingeschränkt |
| Kosten | 0 € | 0 € (MIT) | 0 € (MIT) | Lizenzmodell |
Meine klare Empfehlung für ein Retro-Spiel ist die erste Spalte: Vite, TypeScript und das Canvas-2D-API des Browsers, ohne Engine. Drei Gründe geben den Ausschlag. Erstens kennt Claude die Web-Plattform besser als jede Engine, weil es dazu schlicht am meisten Material gibt. Zweitens brauchst Du für ein Kachelspiel keine Physik, keinen Szenengraphen und keinen Asset-Loader: Eine Schleife, ein Raster und drawImage() reichen. Drittens läuft derselbe Code ohne Umbau in jedem Browser, in der iOS- und Android-App und im Desktop-Wrapper.
Phaser lohnt sich, wenn Dein Spiel echte Physik, viele Sprites mit Animationen oder Tilemaps aus einem Editor braucht. Seit April 2026 ist Phaser 4 final, und genau da liegt eine Falle: Viele Modelle schreiben noch Phaser-3-Code. Pipelines heißen jetzt RenderNodes, preFX und postFX sind zu Filters geworden, und roundPixels steht standardmäßig auf false, was Pixel-Art unscharf macht. Wenn Du Phaser nimmst, verlinke Claude den offiziellen Migration Guide in der CLAUDE.md.
Was Du brauchst
Für das Spiel selbst reicht ein Rechner mit Node.js ab Version 22 und Claude Code. Wie Du Claude Code einrichtest, zeigt die Anleitung: Claude Code auf dem Mac installieren & nutzen. Ein Claude-Abo mit Claude Code (Pro oder Max) deckt das Projekt ab. Für die Apps kommen später Werkzeuge dazu, und erst beim Veröffentlichen in den Stores fallen Gebühren an:
| Ziel | Werkzeug | Kosten |
|---|---|---|
| Browser, itch.io | nur Node.js | kostenlos |
| Android | Android Studio 2025.2.1 oder neuer | 25 US-Dollar einmalig für Google Play |
| iOS | Mac mit Xcode 26 | Apple Developer Program, 99 US-Dollar pro Jahr (in Euro je nach Region) |
| Steam | Electron, Windows/macOS/Linux | 100 US-Dollar pro Spiel, erstattet ab 1.000 US-Dollar Umsatz |
Zum Testen der Gamepad-Steuerung ist ein Bluetooth-Controller wie der 8BitDo (Affiliate Link) praktisch, der sich mit Mac, iPhone und Android verbindet. Und wer kein zweites Smartphone zum Testen hat, findet ein gebrauchtes Android-Handy bei eBay (Affiliate Link) oft für wenig Geld. Für die Performance-Prüfung ist ein älteres, langsames Gerät sogar wertvoller als ein neues.
Schritt 1: Das Projekt anlegen
Leg das Projekt mit der offiziellen Vite-Vorlage für TypeScript an:
npm create vite@latest kristallstollen -- --template vanilla-ts
cd kristallstollen
npm installDamit hast Du einen Dev-Server, TypeScript und einen Build-Prozess. Jetzt kommen das Test-Framework und das PWA-Plugin dazu:
npm install -D vitest vite-plugin-pwa @vite-pwa/assets-generator
npm pkg set scripts.test="vitest run"Der zweite Befehl legt das Skript npm test an, das alle Dateien mit der Endung .test.ts ausführt.
Lösch anschließend die Beispieldateien src/counter.ts und den Ordner src/assets, die Vite als Demo mitbringt. Mit git init und einem ersten Commit hast Du einen sauberen Ausgangspunkt, zu dem Du jederzeit zurückkehren kannst. Das ist bei der Arbeit mit einem Coding-Agent Pflicht, nicht Kür.
Schritt 2: Claude Code für Spieleentwicklung einrichten
Der wichtigste Satz aus Anthropics aktuellen Best Practices für Claude Code lautet sinngemäß: Gib Claude etwas, womit es seine Arbeit selbst prüfen kann. Bei einem Spiel ist das schwieriger als bei einer Webseite, denn ob ein Felsen „richtig“ fällt, sieht man nicht im Code. Die folgenden drei Bausteine lösen genau dieses Problem.
Die CLAUDE.md
Starte Claude Code im Projektordner mit claude und lass mit /init einen ersten Entwurf erzeugen. Kürze ihn danach auf das, was Claude bei jeder Aufgabe wissen muss: Befehle und Regeln, die es sonst falsch machen würde. Meine CLAUDE.md für Kristallstollen sieht so aus:
# Kristallstollen
Retro-Spiel im Stil der 80er, TypeScript + Vite + Canvas 2D, keine Game-Engine.
Läuft im Browser, als PWA, als iOS-/Android-App (Capacitor) und als Desktop-App.
## Befehle
- `npm run dev` startet den Dev-Server auf http://localhost:5173
- `npm test` führt alle Vitest-Tests aus, `npx vitest run tests/world.test.ts` nur einen
- `npx tsc --noEmit` prüft die Typen
- `npm run build` baut nach `dist/`, danach `npx cap sync` für die Apps
## Regeln
- `src/game/` ist reine Spiellogik: kein DOM, kein Canvas, kein Audio, kein `Math.random()`.
Alles dort muss deterministisch und mit Vitest testbar sein.
- Logik läuft in festen Schritten (`TICK_SECONDS`), Rendern so oft der Bildschirm kann.
- Die Logik meldet Ereignisse über `world.events`, Sound und Effekte reagieren nur darauf.
- Plattformcode (Capacitor, Vibration, Speicher) nur in `src/engine/platform.ts`.
- Neue Mechanik: zuerst einen fehlschlagenden Test in `tests/` schreiben, dann umsetzen.
- Interne Auflösung bleibt 320 x 200, Pixel-Art ohne Glättung, keine Bilddateien für Sprites.
- Keine Asset-Pfade mit führendem `/`, damit der Build auf itch.io und in Capacitor läuft.Jede Regel darin verhindert einen Fehler, den ein Coding-Agent bei Spielen gern macht. Warum eine CLAUDE.md kurz bleiben sollte und was nicht hineingehört, steht ausführlich in CLAUDE.md für Claude Code: was rein gehört, was nicht.
Ein Stop-Hook, der Tests erzwingt
Ein Hook ist ein Befehl, den Claude Code automatisch an einer bestimmten Stelle ausführt. Der Stop-Hook läuft, wenn Claude eine Aufgabe für erledigt hält. Leg im Projekt die Datei .claude/settings.json mit diesem Inhalt an:
{
"hooks": {
"Stop": [
{
"hooks": [
{
"type": "command",
"command": "npx tsc --noEmit 1>&2 && npx vitest run 1>&2 || exit 2"
}
]
}
]
}
}Der Befehl prüft die Typen und führt alle Tests aus. Schlägt einer davon fehl, sorgt exit 2 dafür, dass Claude die Fehlermeldung bekommt und weiterarbeitet, statt Dir einen kaputten Stand als fertig zu melden. Mehr Beispiele für solche Automatismen findest Du in Claude Code Hooks: Anleitung mit fünf Beispielen.
Augen für Claude: Playwright im Browser
Damit Claude das laufende Spiel sehen kann, bekommt es über das Model Context Protocol einen echten Browser. Der offizielle Playwright-MCP-Server von Microsoft lässt sich mit einem Befehl einbinden:
claude mcp add playwright -- npx @playwright/mcp@latestDanach kann Claude die Seite öffnen, Tasten drücken und Screenshots machen. Ein Canvas ist für Playwright allerdings eine Blackbox ohne lesbare Struktur. Deshalb legt Kristallstollen im Entwicklungsmodus den Spielzustand auf window.__game offen. Claude kann damit nach einem Tastendruck nachsehen, ob die Figur wirklich drei Kacheln weiter steht, statt einen Screenshot zu deuten. Wie MCP-Server generell funktionieren, erklärt MCP-Server in Claude Code und Codex einrichten.
Modell und Arbeitsmodus
Claude Code startet standardmäßig mit Opus 5.5 auf mittlerem Effort, und das reicht für fast alle Schritte in diesem Guide. Für die Architekturentscheidung am Anfang lohnt /effort high. Größere Umbauten lässt Du im Plan Mode planen, in den Du mit Shift + Tab wechselst oder indem Du /plan vor den Prompt setzt: Claude liest dann nur, schlägt einen Plan vor und ändert erst etwas, wenn Du ihn freigibst. Zwischen zwei Features räumst Du mit /clear den Kontext auf, damit alte Fehlversuche nicht in die neue Aufgabe hineinwirken. Warum das so viel ausmacht, steht in Claude Code: Kontext, /compact, /clear und Subagents.
Schritt 3: Das Spielkonzept als SPEC.md
Der häufigste Fehler beim Spielebauen mit KI ist ein Prompt wie „Bau mir ein Spiel wie Boulder Dash“. Claude füllt dann jede Lücke mit Annahmen, und Du verbringst die nächsten Stunden damit, sie wieder herauszuoperieren. Besser: Lass Dich erst interviewen. Diesen Prompt gibst Du in einer neuen Session ein:
Ich will ein kleines Retro-Spiel im Genre von Boulder Dash (C64, 1984) bauen,
aber mit eigenem Namen, eigener Grafik, eigenen Levels und eigener Musik.
Stack: Vite, TypeScript, Canvas 2D, keine Engine. Ziel: Browser, PWA,
iOS und Android über Capacitor, später Desktop.
Interview mich mit gezielten Fragen, bis Du eine vollständige Spezifikation
schreiben kannst. Schreib sie dann nach SPEC.md: Spielregeln als prüfbare
Sätze, Steuerung je Gerät, Bildschirme und Zustände, Level-Format,
Grafik- und Soundliste, technische Vorgaben. Noch keinen Code.Claude fragt dann nach Dingen, an die Du selbst nicht gedacht hättest: Was passiert, wenn ein Felsen auf einen Kristall fällt? Darf man Felsen nach oben schieben? Was zeigt der Bildschirm nach dem letzten Level? Die wichtigsten Regeln aus meiner SPEC.md lauten so:
## Regeln (pro Logikschritt, 8 Schritte pro Sekunde)
- Felsen und Kristalle fallen, wenn darunter leer ist.
- Liegen sie auf etwas Rundem (Felsen, Kristall, Mauer) und ist links oder rechts
daneben und darunter frei, rollen sie zur Seite ab.
- Ein fallender Felsen tötet Spieler und Gegner. Ein ruhender Felsen über dem
Spieler bleibt liegen.
- Der Spieler gräbt Erde weg, sammelt Kristalle und schiebt Felsen waagerecht,
wenn dahinter frei ist, nach zwei Schritten Anlauf.
- Gegner folgen der linken Wand. Berühren sie den Spieler, explodiert er.
- Trifft ein Felsen einen Gegner, entsteht eine 3x3-Explosion, die zu Kristallen wird.
- Sind genug Kristalle gesammelt, öffnet sich der Ausgang.So formuliert ist jede Regel ein fertiger Testfall. Genau das nutzt der nächste Schritt. Ebenfalls in die SPEC.md gehört das Level-Format. Kristallstollen speichert jedes Level als Liste von Textzeilen mit 40 Zeichen, was sich in jedem Editor lesen und von Claude problemlos entwerfen lässt. Ein Ausschnitt aus dem ersten Level:
'WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW',
'W..........o.....*.......o.......o.....W',
'W.P...o.........o......*........*......W',
'W.......*....##########........o.......W',
'W..o..........o.......#....*...........W',W ist unzerstörbarer Stahl am Rand, # eine Mauer, . Erde, ein Leerzeichen leerer Raum, o ein Felsen, * ein Kristall, P der Spieler, X der Ausgang und F ein Gegner. Zu jedem Level gehören außerdem ein Name, die Zahl der nötigen Kristalle und das Zeitlimit.
Schritt 4: Eine Architektur, die Claude in der Spur hält
Bevor Claude die erste Zeile schreibt, gibst Du die Struktur vor. Bei Spielen trennt sie alles, was berechnet wird, von allem, was man sieht und hört:
src/
game/ reine Spiellogik, deterministisch, ohne Browser-APIs
tiles.ts Kacheltypen und Richtungen
levels.ts Level als ASCII-Karten
world.ts createWorld() und step(): ein Logikschritt
engine/ alles, was den Browser braucht
sprites.ts Pixel-Art und Palette
font.ts Bitmap-Schrift
audio.ts Soundeffekte und Musik
input.ts Tastatur, Gamepad, Touch
platform.ts Capacitor, Vibration, Speicher
main.ts Spielzustände, Hauptschleife, Zeichnen
tests/ Vitest-Tests für die LogikDiese Trennung ist der eigentliche Trick des ganzen Guides. Die Spiellogik in src/game/ kennt weder Canvas noch Tastatur noch Lautsprecher. Sie bekommt nur „Spieler will nach rechts“ und liefert eine neue Welt und eine Liste von Ereignissen wie gem oder explode. Dadurch kann Claude die Logik mit Tests vollständig prüfen, und Du kannst später Grafik, Sound oder Steuerung austauschen, ohne an den Regeln etwas kaputtzumachen.
Schritt 5: Zuerst die Spiellogik, mit Tests
Jetzt geht es an den Code. Starte eine frische Session, damit das lange Interview nicht im Kontext klebt, und gib diesen Prompt:
Lies SPEC.md und CLAUDE.md. Setze nur src/game/ um: tiles.ts, levels.ts mit
einem kleinen Testlevel und world.ts mit createWorld(level) und step(world, input).
Schreib für jede Regel aus SPEC.md zuerst einen Test in tests/world.test.ts,
der fehlschlägt, und implementiere dann, bis alle Tests grün sind.
Kein Rendering, kein DOM.Claude schreibt dann Tests mit Mini-Karten aus ASCII-Zeichen, die sich fast wie eine Zeichnung lesen. Dieser prüft zum Beispiel, dass ein fallender Felsen den Spieler trifft, ein ruhender aber nicht:
it('fallender Felsen zerquetscht den Spieler', () => {
const w = createWorld(lvl(['WWWWW', 'W o W', 'W W', 'W P W', 'WWWWW']));
step(w, null);
step(w, null);
expect(w.state).toBe('dead');
});
it('ruhender Felsen über dem Spieler bleibt liegen', () => {
const w = createWorld(lvl(['WWWWW', 'W o W', 'W P W', 'W W', 'WWWWW']));
step(w, null);
expect(w.state).toBe('playing');
});Das Herz der Logik ist eine Schleife, die das Raster einmal pro Schritt von oben nach unten durchgeht, genau wie die Originale der 80er. Ein Merker sorgt dafür, dass ein Felsen, der gerade eine Zeile nach unten gefallen ist, im selben Durchlauf nicht noch einmal bewegt wird:
const done = new Uint8Array(wd.w * wd.h);
for (let y = 0; y < wd.h; y++) {
for (let x = 0; x < wd.w; x++) {
const i = y * wd.w + x;
if (done[i]) continue;
switch (wd.cells[i].t) {
case T.BOULDER:
case T.GEM: updateFalling(wd, x, y, done); break;
case T.PLAYER: updatePlayer(wd, x, y, input, done); break;
case T.ENEMY: updateEnemy(wd, x, y, done); break;
}
}
}Diese Reihenfolge ist kein Detail. Sie sorgt dafür, dass ganze Felsstapel als Lawine nachrutschen, wenn Du unten einen wegziehst, und sie macht das Spiel vollständig deterministisch: Gleiche Eingaben ergeben immer exakt dasselbe Ergebnis. Darauf baut der stärkste Test im ganzen Projekt auf.
Der Bot, der jedes Level durchspielt
Wenn Du Levels als ASCII-Karte entwirfst, weißt Du nie sicher, ob sie lösbar sind. Lass Claude deshalb einen kleinen Bot schreiben:
Schreib tests/bot.test.ts: Ein Bot sucht per Breitensuche den kürzesten sicheren
Weg zum nächsten Kristall, nach dem Öffnen zum Ausgang. Unsicher sind Felder
neben Gegnern, unter fallenden Felsen und der Schritt nach unten, wenn über dem
Spieler ein Felsen liegt. Der Test spielt jedes Level aus LEVELS mit step()
und erwartet state === 'won'.Der Bot ist dumm, aber vorsichtig, und genau das reicht. Bei Kristallstollen schafft er alle drei Level und braucht dafür jeweils 15 bis 25 Sekunden Spielzeit. Daraus habe ich die Zeitlimits von 110 bis 130 Sekunden abgeleitet: genug Luft für Menschen, aber kein Spaziergang. Jedes neue Level, das Du oder Claude entwerfen, läuft ab jetzt automatisch durch diese Prüfung, und der Stop-Hook verhindert, dass ein unlösbares Level je als fertig gemeldet wird.
Schritt 6: Pixel-Art ohne Grafikprogramm
Für Retro-Grafik brauchst Du weder Photoshop noch Aseprite. Kristallstollen definiert jedes Sprite als 8 x 8 Zeichen, jeder Buchstabe steht für eine Farbe aus der Palette. Gezeichnet wird jedes Pixel doppelt so breit und hoch, was den typischen groben Look der 80er ergibt. So sieht ein Felsen aus:
boulder: [
'..mmmm..',
'.mawaam.',
'mawaaaam',
'maaaaaam',
'maaaaamd',
'mmaaammd',
'.mmmmmd.',
'..dddd..',
],Ein Punkt ist transparent, m, a, w und d sind Grautöne von mittel bis weiß und dunkel. Beim Start malt das Spiel jedes Sprite einmal in eine kleine Canvas-Fläche und kopiert es danach nur noch per drawImage(). Der Clou für die Arbeit mit Claude: Sprites sind jetzt Text. Ein Prompt wie „Gib dem Spieler einen gelben Helm mit Lampe und eine zweite Laufanimation“ ändert die Grafik direkt, und Du siehst das Ergebnis nach dem Speichern sofort im Browser.
Damit die Pixel beim Hochskalieren scharf bleiben, rendert das Spiel intern mit der C64-Auflösung von 320 x 200 Pixeln und vergrößert per CSS:
#screen {
width: 100%;
height: 100%;
image-rendering: pixelated;
}Dazu kommt im Code ctx.imageSmoothingEnabled = false und eine Bitmap-Schrift mit 3 x 5 Pixeln pro Zeichen, ebenfalls als Text definiert. Echte Schriftarten wirken auf einem Pixel-Canvas immer verwaschen. Wenn Du statt Pixel-Art lieber gemalte Hintergründe oder ein Titelbild willst, kann Claude Code sie auch selbst erzeugen, wie in Anleitung: Bilder in Claude Code generieren mit FLUX beschrieben.
Schritt 7: Sound und Musik wie vom SID-Chip
Der Soundchip des C64 hatte drei Stimmen mit Rechteck-, Dreieck-, Sägezahn- und Rauschwellen. All das kann die Web Audio API von Haus aus, und zwar ohne eine einzige Audiodatei. Ein Soundeffekt ist eine Handvoll Zeilen:
function tone(freq, freqEnd, dur, type, vol) {
const t = ctx.currentTime;
const o = ctx.createOscillator();
const g = ctx.createGain();
o.type = type;
o.frequency.setValueAtTime(freq, t);
o.frequency.exponentialRampToValueAtTime(freqEnd, t + dur);
g.gain.setValueAtTime(vol, t);
g.gain.exponentialRampToValueAtTime(0.0001, t + dur);
o.connect(g).connect(sfxBus);
o.start(t);
o.stop(t + dur + 0.02);
}Das Einsammeln eines Kristalls sind zwei kurze Rechtecktöne hintereinander, ein landender Felsen ist gefiltertes Rauschen plus ein tiefer Sinus, der Tod ein fallender Sägezahn. Die Musik ist ein kleiner Sequenzer mit 132 Schlägen pro Minute: Bass in Achteln, ein schnelles Akkord-Arpeggio in Sechzehnteln, wie es typisch für C64-Musik war, eine Melodie in der zweiten Hälfte und Rauschen als Schlagzeug. Damit die Töne exakt im Takt bleiben, plant der Sequenzer sie mit ctx.currentTime rund 120 Millisekunden im Voraus, statt sie per Timer direkt abzuspielen. Ein einfacher Prompt dafür lautet: „Schreib in audio.ts einen Lookahead-Sequenzer mit vier Takten Am, F, C, G und einer eigenen Melodie, Bass als Rechteck, Arpeggio, Drums aus Rauschen“.
Wenn Du lieber mit einem fertigen Werkzeug arbeitest: ZzFX ist ein Soundeffekt-Generator unter MIT-Lizenz mit unter einem Kilobyte, dessen Effekte Du im Browser zusammenklickst und als eine Zeile Code übernimmst.
Die zwei Audio-Fallen auf dem Smartphone
Zwei Dinge musst Du von Anfang an einbauen, sonst bleibt das Spiel auf vielen Geräten stumm. Erstens darf eine Webseite erst nach einer Nutzergeste Ton abspielen. Ein AudioContext, der vorher entsteht, bleibt im Zustand suspended. Kristallstollen erzeugt ihn deshalb erst beim ersten Tipp, Klick oder Tastendruck. Zweitens behandelt Safari auf dem iPhone Web Audio standardmäßig wie Hintergrundgeräusche, die der Stummschalter abschaltet. Für ein Spiel, das man bewusst startet, ist das falsch, und Safari bietet dafür seit Version 16.4 eine eigene Schnittstelle:
export function unlockAudio() {
if (!ctx) {
const nav = navigator as Navigator & { audioSession?: { type: string } };
if (nav.audioSession) {
try { nav.audioSession.type = 'playback'; } catch {}
}
ctx = new AudioContext();
// Lautstärkeregler und Busse anlegen ...
}
if (ctx.state === 'suspended') void ctx.resume();
}Die Zeile mit audioSession ist auf allen anderen Browsern harmlos, weil sie dort einfach übersprungen wird. Dazu kommt ein Handler für visibilitychange, der das Spiel pausiert und den Ton anhält, sobald Du die App wechselst.
Schritt 8: Eine Steuerung für Tastatur, Gamepad und Touch
Der Schlüssel zur Plattformunabhängigkeit ist eine Eingabeschicht, die alle Geräte auf dieselben drei Dinge reduziert: eine Richtung, eine Aktion und Pause. Die Spiellogik erfährt nie, ob Du gerade eine Pfeiltaste, einen Analogstick oder Deinen Daumen benutzt.
- Tastatur: Pfeiltasten und WASD, Leertaste für Start,
Pfür Pause,Mfür den Ton. Gedrückte Richtungen landen auf einem Stapel, die zuletzt gedrückte gewinnt. - Gamepad: Die Gamepad API wird einmal pro Bild abgefragt. Steuerkreuz und linker Stick geben die Richtung, die untere Taste startet, die Start-Taste pausiert.
- Touch: ein virtuelles Steuerkreuz, das nur auf Geräten mit grobem Zeiger erscheint, erkannt über
matchMedia('(pointer: coarse)').
Beim Steuerkreuz steckt der Teufel im Detail. Statt vier einzelner Knöpfe ist es ein einziges Element, das die Richtung aus der Position des Fingers relativ zur Mitte berechnet. So kannst Du mit dem Daumen von rechts nach unten rutschen, ohne abzusetzen, wie auf einem echten Steuerkreuz. Damit der Finger auch dann noch zählt, wenn er über den Rand hinausrutscht, hält setPointerCapture() ihn fest:
dpad.addEventListener('pointerdown', (e) => {
e.preventDefault();
dpad.setPointerCapture(e.pointerId);
update(e);
});
dpad.addEventListener('pointermove', (e) => {
if (dpad.hasPointerCapture(e.pointerId)) update(e);
});
dpad.addEventListener('pointerup', end);
dpad.addEventListener('pointercancel', end);Pointer Events statt der alten Touch Events haben einen Vorteil: Derselbe Code funktioniert mit Maus, Stift und Finger, und jeder Finger hat eine eigene pointerId. Ein weiteres Detail aus dem Praxistest: Tippt jemand schnell zweimal, landen beide Tipps zwischen zwei Logikschritten. Ohne Puffer geht einer verloren, deshalb merkt sich die Eingabeschicht bis zu drei Antipper und gibt sie Schritt für Schritt aus.
Die index.html als Gerüst
Die Seite selbst ist schlicht: ein Canvas und darunter die Touch-Steuerung, die per CSS nur auf Touch-Geräten erscheint. Entscheidend sind die Meta-Tags im Kopf:
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
<meta name="theme-color" content="#000000" />
<meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />Und im Body:
<main id="app">
<div id="frame">
<canvas id="screen" width="320" height="200" aria-label="Spielfeld"></canvas>
</div>
<div id="controls">
<div id="dpad" aria-label="Steuerkreuz">
<span class="arm up"></span><span class="arm right"></span>
<span class="arm down"></span><span class="arm left"></span>
</div>
<div id="buttons">
<button id="btn-pause" aria-label="Pause">II</button>
<button id="btn-sound" aria-label="Ton an oder aus">♪</button>
<button id="btn-full" aria-label="Vollbild">⛶</button>
</div>
</div>
</main>
<script type="module" src="./src/main.ts"></script>viewport-fit=cover lässt das Spiel bis in die Ecken des Displays reichen, die Statusleisten-Einstellung färbt die Leiste der installierten Web-App schwarz.
CSS, damit der Browser nicht dazwischenfunkt
Auf dem Smartphone will der Browser bei jeder Wischgeste scrollen, zoomen oder neu laden. Diese Regeln schalten das für das Spiel ab:
html, body {
overscroll-behavior: none;
}
body {
-webkit-user-select: none;
user-select: none;
-webkit-touch-callout: none;
-webkit-tap-highlight-color: transparent;
touch-action: none;
}
#app {
height: 100dvh;
padding: env(safe-area-inset-top) env(safe-area-inset-right)
env(safe-area-inset-bottom) env(safe-area-inset-left);
}overscroll-behavior verhindert das Neuladen durch Herunterziehen, touch-action: none das Zoomen per Doppeltipp, -webkit-touch-callout die Lupe beim langen Drücken auf dem iPhone. Die safe-area-inset-Werte halten Notch, Dynamic Island und Home-Indikator frei, funktionieren aber nur zusammen mit viewport-fit=cover im Viewport-Tag der index.html. Und 100dvh statt 100vh berücksichtigt die ein- und ausfahrende Adressleiste mobiler Browser.
Für das Layout gibt es zwei Fälle. Im Hochformat sitzt das Spielbild oben und das Steuerkreuz darunter, im Querformat liegt die Steuerung halbtransparent links und rechts über dem Bild. Beides regelt eine CSS-Media-Query auf orientation, ganz ohne JavaScript. Einen Vollbild-Knopf blendet das Spiel nur ein, wo er funktioniert: Auf dem iPhone unterstützt Safari das Vollbild für Webseiten bis heute nicht, dort hilft die Installation als Web-App aus Schritt 12.
Schritt 9: Juice, damit es sich gut anfühlt
Jetzt funktioniert das Spiel, aber es fühlt sich noch steif an. Spieleentwickler nennen die kleinen Rückmeldungen, die das ändern, „Juice“. Sie kommen bewusst erst jetzt, wenn der Kern läuft, und sie hängen alle an den Ereignissen, die die Spiellogik meldet:
| Ereignis | Effekt |
|---|---|
| Erde gegraben | kurzes Rauschen, vier braune Krümel-Partikel |
| Kristall gesammelt | Zweiklang, zwölf funkelnde Partikel, leichte Vibration |
| Felsen gelandet | dumpfer Schlag, Bildschirm wackelt 2 Pixel, nur wenn sichtbar |
| Explosion | Donner, Bildschirm wackelt 7 Pixel, 40 Funken, starke Vibration |
| Ausgang offen | aufsteigendes Arpeggio, weißer Lichtblitz |
| Zeit unter 10 Sekunden | Ticken, Zeitanzeige blinkt rot |
Dazu kommt eine Kamera, die der Spielfigur weich folgt statt zu springen, und eine Röhrenmonitor-Optik aus zwei CSS-Verläufen über dem Canvas: feine Scanlines und eine leichte Abdunklung der Ecken. Der Prompt dafür kann ganz knapp sein: „Ergänze Juice nach der Tabelle in SPEC.md, nur in main.ts und audio.ts, die Spiellogik bleibt unverändert.“ Der letzte Halbsatz ist wichtig, denn sonst baut Claude gern Effekte direkt in die Logik ein und bricht damit die Tests.
Schritt 10: Die Hauptschleife mit festem Zeittakt
Ein Bildschirm zeigt 60, 120 oder 144 Bilder pro Sekunde, je nach Gerät. Würde die Spiellogik bei jedem Bild einen Schritt machen, liefe das Spiel auf einem iPad Pro doppelt so schnell wie auf einem alten Android-Handy. Die Lösung ist der feste Zeittakt, den Glenn Fiedler in seinem Klassiker Fix Your Timestep! beschrieben hat:
let acc = 0;
function frame(now: number) {
const dt = Math.min(0.1, (now - last) / 1000);
last = now;
acc += dt;
while (acc >= TICK_SECONDS) {
step(world, input.consumeDir());
handleEvents();
acc -= TICK_SECONDS;
}
render(dt);
requestAnimationFrame(frame);
}Die Logik läuft exakt achtmal pro Sekunde, gezeichnet wird so oft, wie der Bildschirm kann. Die Begrenzung auf 0,1 Sekunden verhindert, dass das Spiel nach einer Pause im Hintergrund hunderte Schritte auf einmal nachholt.
Um diese Schleife herum liegt ein kleiner Zustandsautomat mit acht Zuständen: Titelbild, Level-Intro, Spielen, Pause, Tod, Level geschafft, Game Over und Sieg. Jeder Zustand entscheidet selbst, was Eingaben bewirken und wann es weitergeht. Ein Prompt dafür: „Baue in main.ts die Zustände title, intro, playing, paused, dead, levelDone, gameover und victory. Leben, Gesamtpunkte und Highscore in localStorage, Highscore-Zugriff in try/catch. Nach dem Tod läuft die Welt 2,4 Sekunden weiter, damit die Explosion sichtbar ausklingt.“
Schritt 11: Testen auf allen Geräten
Getestet wird in vier Stufen, von automatisch bis echt:
- Logik:
npm testführt die Regel-Tests und den Level-Bot aus. Bei Kristallstollen sind das 17 Tests in unter einer Sekunde. - Browser:
npm run devstartet den Dev-Server. Mit?debughinter der Adresse zeigt das Spiel Bilder pro Sekunde und den Logikschritt an. Mit Playwright kann Claude hier selbst spielen, etwa mit dem Prompt: „Öffne localhost:5173, starte das Spiel, halte zwei Sekunden die Pfeiltaste nach unten, mach einen Screenshot und prüfe über window.__game, dass der Spieler sich bewegt hat und keine Konsolenfehler auftreten.“ - Smartphone-Ansicht: Die Gerätesimulation der Entwicklerwerkzeuge in Chrome oder Safari zeigt Hoch- und Querformat und schaltet die Touch-Steuerung frei, weil sie einen groben Zeiger meldet.
- Echtes Gerät: Starte den Dev-Server mit
npm run dev -- --host. Vite zeigt dann zusätzlich eine Adresse wiehttp://192.168.178.20:5173, die Du auf dem Smartphone im selben WLAN öffnest. Erst hier merkst Du, ob das Steuerkreuz gut unter dem Daumen liegt und ob der Ton trotz Stummschalter läuft.
Woran Du erkennst, dass alles passt: Die Figur bewegt sich mit 8 Schritten pro Sekunde gleichmäßig, egal auf welchem Gerät, die Konsole bleibt ohne Fehler, der Ton startet nach dem ersten Tipp, und auf dem Handy scrollt und zoomt nichts, egal wie wild Du wischst.
Schritt 12: Als Web-App installierbar und offline spielbar
Mit vite-plugin-pwa wird aus dem Spiel eine Progressive Web App, die sich wie eine App auf dem Home-Bildschirm installieren lässt und ohne Internet läuft. Die vite.config.ts dafür:
import { defineConfig } from 'vite';
import { VitePWA } from 'vite-plugin-pwa';
export default defineConfig({
base: './',
plugins: [
VitePWA({
registerType: 'autoUpdate',
includeAssets: ['favicon.svg', 'apple-touch-icon-180x180.png'],
manifest: {
name: 'Kristallstollen',
short_name: 'Kristall',
lang: 'de',
start_url: './',
display: 'fullscreen',
background_color: '#000000',
theme_color: '#000000',
icons: [
{ src: 'pwa-192x192.png', sizes: '192x192', type: 'image/png' },
{ src: 'pwa-512x512.png', sizes: '512x512', type: 'image/png' },
{ src: 'maskable-icon-512x512.png', sizes: '512x512', type: 'image/png', purpose: 'maskable' },
],
},
}),
],
});Die Zeile base: './' ist wichtiger, als sie aussieht. Sie sorgt dafür, dass alle Pfade relativ sind, und genau das brauchen itch.io, Capacitor und Electron. Ohne sie bekommst Du dort einen schwarzen Bildschirm. Die Icons erzeugt der offizielle Generator aus einem einzigen SVG:
npx pwa-assets-generator --preset minimal-2023 public/favicon.svgNach npm run build liegt das fertige Spiel im Ordner dist, inklusive Manifest und Service Worker. Chrome bietet die Installation automatisch an, sobald die Seite über HTTPS läuft. Auf dem iPhone öffnest Du die Seite in Safari, tippst auf „Teilen“, dann auf „Zum Home-Bildschirm“ und lässt den Schalter „Als Web-App öffnen“ aktiviert. Das Spiel startet danach ohne Adressleiste, und weil Safari display: fullscreen nicht kennt, fällt es dabei automatisch auf den Modus standalone zurück.
Veröffentlichen: vom Browser bis Steam
Ab hier ist das Spiel fertig, und es geht nur noch um die Verpackung. Der Inhalt von dist bleibt überall derselbe.
itch.io: kostenlos und in fünf Minuten
itch.io ist der natürliche erste Ort für ein Indie-Spiel. Das Hochladen kostet nichts, und den Anteil, den itch.io an Verkäufen bekommt, legst Du selbst fest, auch null. Pack den Build in ein ZIP-Archiv:
cd dist
zip -r ../kristallstollen-web.zip .
cd ..Wichtig ist, dass die index.html direkt im ZIP liegt und nicht in einem Unterordner. Laut der HTML5-Doku von itch.io darf ein Archiv höchstens 1.000 Dateien und entpackt 500 MB haben, was Kristallstollen mit seinen rund 100 KB nicht ansatzweise erreicht. Auf der Projektseite stellst Du die Art auf „HTML“, lädst das ZIP hoch, setzt den Haken bei „This file will be played in the browser“ und wählst als Größe 960 x 600 Pixel, das Dreifache der internen Auflösung. Den Haken bei „Mobile friendly“ kannst Du guten Gewissens setzen, denn die Touch-Steuerung ist ja eingebaut.
Für spätere Updates lohnt sich das Kommandozeilenwerkzeug butler, das nur geänderte Dateien hochlädt:
butler push dist deinname/kristallstollen:html5Ersetze deinname durch Deinen itch.io-Benutzernamen und kristallstollen durch den Namen Deiner Projektseite.
Android und iOS mit Capacitor
Capacitor packt den Web-Build in eine echte native App mit WebView. In Version 8 sieht die Einrichtung so aus:
npm install @capacitor/core @capacitor/haptics
npm install -D @capacitor/cli
npx cap init Kristallstollen com.example.kristallstollen --web-dir dist
npm install @capacitor/android @capacitor/ios
npx cap add android
npx cap add iosErsetze com.example.kristallstollen durch eine eigene, umgekehrte Domain, etwa de.deinname.kristallstollen. Diese App-ID lässt sich nach der ersten Veröffentlichung nicht mehr ändern. Das Android-Projekt nutzt minSdk 24 und targetSdk 36, das iOS-Projekt verwaltet seine Abhängigkeiten seit Capacitor 8 standardmäßig über den Swift Package Manager.
Nach jeder Änderung am Spiel baust Du neu und kopierst den Stand in die nativen Projekte:
npm run build
npx cap syncMit npx cap open android beziehungsweise npx cap open ios öffnest Du das Projekt in Android Studio oder Xcode und startest es dort auf einem Gerät oder im Emulator.
Die einzige Stelle im Code, die von Capacitor weiß, ist platform.ts. Dort kommt zum Beispiel die Vibration her: In der nativen App über das Haptics-Plugin, das auch auf dem iPhone vibriert, im Browser über navigator.vibrate, das nur Android kennt:
import { Capacitor } from '@capacitor/core';
import { Haptics, ImpactStyle } from '@capacitor/haptics';
export const isNative = Capacitor.isNativePlatform();
export function rumble(strong = false) {
if (isNative) {
void Haptics.impact({ style: strong ? ImpactStyle.Heavy : ImpactStyle.Light });
} else if ('vibrate' in navigator) {
navigator.vibrate(strong ? 60 : 15);
}
}So bleibt der Rest des Spiels universell, und trotzdem fühlt sich jede Plattform richtig an.
Android-Besonderheit: Ab targetSdk 35 zeichnet Android Apps bis unter Status- und Navigationsleiste. Capacitor 8 regelt das über das System-Bars-Plugin und die Einstellung insetsHandling. Bei WebViews ab Version 140 liefern die safe-area-inset-Werte aus dem CSS dann korrekte Abstände. Prüf auf einem echten Gerät, dass HUD und Steuerkreuz nicht unter den Systemleisten verschwinden.
Google Play
Für Google Play brauchst Du ein Entwicklerkonto für einmalig 25 US-Dollar mit Identitätsprüfung. In Android Studio erzeugst Du über das Menü Build und den Assistenten für signierte Bundles ein signiertes Android App Bundle (.aab), denn APKs nimmt Google Play für neue Apps nicht mehr an. Seit dem 31. August 2026 müssen neue Apps und Updates laut den Target-API-Vorgaben auf API 36 zielen, was Capacitor 8 bereits tut.
Die größte Hürde für Hobby-Entwickler: Bei persönlichen Konten, die nach dem 13. November 2023 angelegt wurden, verlangt Google vor der ersten Veröffentlichung einen geschlossenen Test mit mindestens 12 Testern über 14 Tage am Stück, nachzulesen in den Testanforderungen für neue Konten. Plane diese zwei Wochen ein und such Dir Tester im Freundeskreis oder in einer Indie-Community. Außerdem musst Du in der Play Console unter App-Inhalte > Datensicherheit angeben, welche Daten das Spiel erhebt, auch wenn die Antwort „keine“ lautet, und eine Datenschutzerklärung verlinken.
App Store
Für iOS brauchst Du das Apple Developer Program für 99 US-Dollar pro Jahr, in Deutschland wird der Betrag in Euro abgerechnet. Seit dem 28. April 2026 müssen Uploads mit Xcode 26 und dem iOS-26-SDK gebaut sein. In Xcode wählst Du Product > Archive und lädst den Build hoch. Über TestFlight testest Du ihn erst mit bis zu 100 Teammitgliedern ohne Prüfung, dann mit bis zu 10.000 externen Testern, für die der erste Build eine kurze Beta-Prüfung durchläuft.
Bei der App-Prüfung ist Abschnitt 4.2 der App Store Review Guidelines entscheidend: Apps müssen mehr sein als eine umverpackte Website. Ein Spiel, dessen gesamter Code in der App steckt, das offline läuft und native Haptik nutzt, erfüllt das. Eine App, die nur eine Webseite aus dem Internet lädt, fällt dagegen durch. Dazu kommen die Datenschutzangaben in App Store Connect und eine Datenschutzerklärung.
Desktop und Steam
Für den Desktop gibt es zwei Verpackungen. Tauri 2 erzeugt sehr kleine Apps für macOS, Windows und Linux, weil es die WebView des Systems nutzt. Es braucht eine Rust-Installation und wird mit diesen Befehlen eingebunden:
npm install -D @tauri-apps/cli@latest
npx tauri init
npx tauri buildBei tauri init gibst Du ../dist als Ordner der Web-Dateien und http://localhost:5173 als Dev-Adresse an. Für eine Veröffentlichung auf itch.io oder der eigenen Website ist Tauri die schlankste Lösung.
Für Steam ist Electron derzeit der praktikablere Weg. Das Steam-Overlay und die Steamworks-Funktionen wie Erfolge laufen über Bibliotheken wie steamworks.js, die Electron unterstützen, während das Overlay mit Tauri nach Berichten aus der Community nicht funktioniert. Beachte, dass steamworks.js zuletzt 2024 aktualisiert wurde. Die Eckdaten von Steam laut Steamworks-Doku: 100 US-Dollar pro Spiel, die nach 1.000 US-Dollar Umsatz zurückkommen, und eine Store-Seite, die mindestens zwei Wochen vor dem Start als „Demnächst verfügbar“ sichtbar sein muss. Für die Einstufung „Steam Deck Verified“ braucht das Spiel volle Controller-Unterstützung, was Kristallstollen dank der Gamepad-Abfrage schon mitbringt, und gut lesbaren Text bei 1280 x 800 Pixeln. Die Desktop-Schritte habe ich nach der offiziellen Doku beschrieben, aber nicht selbst bis zum Store durchgespielt.
Prompts, die sich bewährt haben
Diese Prompts haben beim Bau von Kristallstollen am besten funktioniert. Sie sind bewusst eng gefasst, denn je kleiner die Aufgabe, desto besser das Ergebnis.
- Neues Level: „Entwirf ein viertes Level im Format von levels.ts, 40 x 22, Thema ‚Die Lawine’: viele Felsstapel, zwei Gegner in Kammern, 20 Kristalle nötig. Prüf es mit dem Bot-Test und passe es an, bis der Bot es schafft.“
- Neue Mechanik: „Neue Regel: Magische Mauer verwandelt fallende Felsen in Kristalle. Schreib zuerst drei fehlschlagende Tests in world.test.ts, dann die Umsetzung. Keine Änderungen außerhalb von src/game/ und tests/.“
- Fehler: „Felsen bleiben manchmal in der Luft hängen. Schreib einen Test, der das reproduziert, und behebe dann die Ursache.“ Diese Reihenfolge empfiehlt auch Anthropic ausdrücklich.
- Grafik: „Überarbeite das Spieler-Sprite in sprites.ts: Bergmann mit gelbem Helm und Stirnlampe, zwei Laufbilder, nur Farben aus PALETTE.“
- Feel: „Das Schieben von Felsen fühlt sich träge an. Schlag drei Varianten vor, wie wir es direkter machen, ohne die Regeln in SPEC.md zu verletzen. Noch nichts umsetzen.“
- Review:
/code-reviewlässt einen frischen Subagent den Stand gegen SPEC.md prüfen. Mit dem Zusatz „ignoriere Stilfragen“ bekommst Du nur echte Fehler.
Und ein Prompt, den Du am Anfang jeder neuen Session parat haben solltest: „Lies CLAUDE.md und SPEC.md, führe npm test aus und sag mir in drei Sätzen, wo wir stehen.“ Damit holt sich Claude den Kontext selbst, statt Dich zu fragen.
Typische Fehler und wie Du sie behebst
Schwarzer Bildschirm auf itch.io oder in der App. Fast immer liegen die Pfade falsch. Prüf, ob base: './' in der vite.config.ts steht, ob im Code kein Pfad mit / beginnt, etwa bei fetch('/levels.json') oder in einer CSS-Angabe url('/bild.png'), und ob die index.html im ZIP ganz oben liegt. Die Pfade in der index.html selbst schreibt Vite beim Build automatisch um.
Kein Ton auf dem iPhone. Entweder wird der AudioContext vor der ersten Berührung erzeugt, oder der Stummschalter ist aktiv und navigator.audioSession.type = 'playback' fehlt. In der nativen App über Capacitor tritt das Stummschalter-Problem nicht auf.
Unscharfe Pixel. image-rendering: pixelated im CSS fehlt oder imageSmoothingEnabled wurde nach einer Größenänderung des Canvas wieder zurückgesetzt. Setz es nach jedem Ändern von width oder height erneut.
Die Seite scrollt oder zoomt beim Spielen. touch-action: none gehört auf den Body und das Steuerkreuz, overscroll-behavior: none auf html und body.
Das Spiel läuft auf dem Gaming-Monitor zu schnell. Die Logik hängt direkt an requestAnimationFrame, statt in festen Schritten zu laufen. Der Abschnitt zur Hauptschleife zeigt die Lösung.
Nach einem Update sehen Spieler die alte Version. Der Service Worker liefert den Cache aus. Mit registerType: 'autoUpdate' aktualisiert er sich beim nächsten Start, im Zweifel hilft auf dem Testgerät einmal das Löschen der Website-Daten.
Claude schreibt Phaser-3-Code für Phaser 4. Verweise in der CLAUDE.md auf den Migration Guide und schreib dazu, welche Version im Projekt steckt. Bei der Canvas-Variante dieses Guides gibt es das Problem nicht.
Checkliste vor dem Release
- Alle Tests grün, der Bot schafft jedes Level,
npm run buildohne Warnungen. - Auf einem echten iPhone und einem echten Android-Gerät gespielt, in beiden Ausrichtungen.
- Ton startet nach dem ersten Tipp, Pause beim App-Wechsel funktioniert.
- Name, Grafik, Musik und Level sind eigene Arbeit, nichts aus dem Original übernommen.
- Icons in allen Größen, Datenschutzerklärung online, auch wenn das Spiel keine Daten sammelt.
- Für Google Play die 14 Tage geschlossenen Test eingeplant, für Steam die zwei Wochen Vorlauf.
Fazit
Ein Retro-Spiel ist das ideale Projekt, um mit Claude Code etwas Fertiges zu bauen statt einer ewigen Baustelle. Der entscheidende Teil ist nicht der Prompt, der das Spiel erzeugt, sondern die Struktur drumherum: eine Spezifikation, aus der Tests werden, eine Spiellogik, die ohne Browser läuft, und ein Hook, der Claude nichts als fertig melden lässt, was die Tests nicht besteht. Mit Vite, TypeScript und Canvas bleibt das Ergebnis winzig, und derselbe Ordner dist landet unverändert im Browser, auf itch.io, in der iPhone- und Android-App und auf dem Desktop. Fang mit itch.io an, denn das kostet nichts und bringt in fünf Minuten echte Spieler, und geh erst in die Stores, wenn Dein Spiel dort Freude macht.
Weiterlesen.
-
KIAnleitung: Claude Code auf dem Mac installieren & nutzen
Claude Code auf dem Mac installieren, anmelden und sinnvoll nutzen: die wichtigsten Konzepte und drei Alltags-Workflows jenseits vom Programmieren.
Nathan Base -
KICLAUDE.md für Claude Code: was rein gehört, was nicht
So schreibst Du eine CLAUDE.md, an die sich Claude Code hält: was hinein gehört, was nicht, Ladeorte, Vorlage und ein echtes Beispiel.
Nathan Base -
KIClaude Code Hooks: Anleitung mit fünf Beispielen
So richtest Du Hooks in Claude Code ein: settings.json, PreToolUse und PostToolUse, Exit-Codes und fünf Beispiele von Prettier bis zur .env-Sperre.
Nathan Base -
KIClaude Code: Kontext, /compact, /clear und Subagents
Warum lange Sitzungen in Claude Code schlechter werden und wie Du mit /context, /compact, /clear und Subagents Kontext und Nutzungslimit im Griff hältst.
Nathan Base -
KIMCP-Server in Python bauen: Claude liest Home Assistant
Eigenen MCP-Server in Python bauen: mit SDK 2, uv und Inspector Tools und eine Ressource schreiben und in Claude Code und Claude Desktop nutzen.
Nathan Base -
KIOllama auf dem Mac: lokale KI mit MLX nutzen
Ollama auf dem Mac: lokale Modelle nach Arbeitsspeicher wählen und mit OpenCode, Claude Code oder Codex, VS Code, Docker und GitHub programmieren.
Nathan Base