Programmieren mit KI

Worum es geht

Beim Programmieren mit KI, auch Vibecoding genannt, beschreibst du in Alltagssprache, was dein Programm tun soll. Eine KI schreibt den Code, du probierst ihn aus und sagst, was noch anders sein soll. Den Begriff Vibecoding hat Anfang 2025 der KI-Forscher Andrej Karpathy geprägt.

Die KI-Systeme dahinter sind Sprachmodelle. Sie haben aus riesigen Mengen Text gelernt, was wahrscheinlich als Nächstes kommt – darunter sehr viel Programmcode. Daraus folgt, was sie gut können und wo sie danebenliegen:

Gut	Schwach
Übliche Aufgaben, die es tausendfach gibt: Schleifen, Kollisionen, Menüs	Seltene Hardware wie den PBC+, die sie kaum kennen
Code erklären, Zeile für Zeile	Wissen, was in deinem Programm steht, wenn du es nicht zeigst
Fehlermeldungen deuten	Merken, dass ihr Code falsch ist, ohne ihn auszuprobieren
Vorschläge für Aufbau und Namen	Zugeben, dass sie etwas nicht wissen – sie antworten trotzdem, oft überzeugend falsch

Chat oder Agent?

Mit einem Chat-System

1. Gespräch beginnen. Ein neues Gespräch in ChatGPT, Gemini oder Claude öffnen.
2. Regeln geben. Als Erstes den System-Prompt für deine Sprache einfügen.
3. Aufgabe stellen. Klein und genau beschreiben, was du willst – wie in den Beispielen.
4. Ausprobieren. Den Code übernehmen, bauen und aufspielen – bei Python geht es am schnellsten im PBC+ Studio mit Testen. Bei einem Fehler die ganze Meldung zurück an die KI geben.

Tipp: Viele Chat-Systeme können Anweisungen dauerhaft speichern, etwa in „Projekten“. Dann musst du den System-Prompt nur einmal hinterlegen.

Mit einem Agenten

1. Ordner anlegen. Einen Ordner für dein Programm anlegen und darin Codex oder Claude Code starten.
2. Regeln geben. Den System-Prompt für deine Sprache als AGENTS.md in den Ordner legen. Für Claude Code daneben eine CLAUDE.md mit der Zeile @AGENTS.md – so lesen beide dieselben Regeln.
3. Aufgabe stellen. Klein und genau beschreiben, was du willst – wie in den Beispielen.
4. Ausprobieren. Der Agent baut selbst und liefert eine fertige .uf2-Datei. Die ziehst du im Bootmodus aufs Gerät.

Tipp: Welcher Prompt zu welcher Sprache gehört, zeigt die Tabelle im nächsten Abschnitt. Beide Handbücher erklären das Arbeiten mit KI ausführlich im letzten Kapitel.

Welche Sprache?

KI hilft in jeder dieser Sprachen – aber nicht überall gleich. Am meisten nimmt sie dir bei C/C++ und Arduino ab: Ein Agent kann dort selbst übersetzen, seine Fehler lesen und beheben und dir am Ende eine fertige .uf2-Datei liefern. Die ziehst du nur noch aufs Gerät.

	Mit einem Chat	Mit einem Agenten	Regeln für die KI
Python	Programm ins PBC+ Studio kopieren, im Emulator testen.	Schreibt die .py-Datei; du öffnest sie im Studio.	Prompt Python
Arduino	Sketch in die Arduino IDE kopieren und hochladen.	Übersetzt mit arduino-cli und liefert die .uf2.	Prompt Arduino
C / C++	Code in ein Pico-SDK-Projekt übernehmen, in VS Code bauen.	Baut mit dem Pico SDK und liefert die .uf2.	Prompt Pico SDK

Zum Bauen braucht der Agent Werkzeuge auf deinem Computer: für Arduino arduino-cli mit dem Kern arduino-pico, für C/C++ das Pico SDK mit CMake und dem ARM-Compiler. Die musst du nicht selbst einrichten: Bitte den Agenten darum – er installiert, was fehlt, und fragt vorher um Erlaubnis. Du brauchst nur den Agenten selbst.

Die System-Prompts

Der System-Prompt erklärt der KI, wofür sie Code schreibt: welches Gerät, welche Befehle es gibt und welche Regeln gelten. Ohne ihn rät die KI – und rät falsch. Nimm den Prompt für deine Sprache: im Chat als erste Nachricht einfügen, für einen Agenten als AGENTS.md in den Projektordner legen.

Python im PBC+ Studio

Für Chat-Systeme: Die KI schreibt MicroPython mit dem Modul pbc, das du ins PBC+ Studio kopierst. Wenig Hardware, dafür alle Befehle.

Du hilfst beim Programmieren des PicoBoy Color Plus (PBC+), eines kleinen
Handhelds. Programmiert wird in MicroPython im PBC+ Studio (pbcstudio.de,
Textmodus). Die Person, mit der du sprichst, lernt gerade programmieren.

## Das Gerät
- Farbdisplay 240 x 280 Pixel, (0, 0) oben links, y nach unten.
  Die Ecken sind abgerundet: etwa 20 Pixel Rand freilassen.
- Joystick (hoch, runter, links, rechts, Mitte), Tasten A und B,
  drei LEDs (rot, gelb, grün), eine RGB-LED, Lautsprecher, Beschleunigungssensor.

## Regeln für den Code
- Jedes Programm beginnt mit `import pbc`. Weitere Module ausdrücklich
  importieren: `time`, `random`, `math`, `os`, `turtle`.
- Für die Hardware NUR diese Befehle benutzen und keine weiteren erfinden:
  - Bildschirm: `pbc.WIDTH`, `pbc.HEIGHT`, Farben `pbc.BLACK WHITE RED GREEN
    BLUE YELLOW CYAN MAGENTA ORANGE PURPLE GRAY`, `pbc.rgb(r, g, b)`,
    `pbc.clear(farbe)`, `pbc.pixel(x, y, farbe)`, `pbc.line(x1, y1, x2, y2, farbe)`,
    `pbc.rect(x, y, b, h, farbe)` bzw. mit `fill=True`, `pbc.fill_rect(x, y, b, h, farbe)`,
    `pbc.ellipse(mx, my, rx, ry, farbe)` bzw. mit `fill=True`,
    `pbc.text(s, x, y, farbe)`, `pbc.text12/text18/text24(s, x, y, farbe)`,
    `pbc.text12_width(s)` (ebenso 18 und 24), `pbc.delay(ms)`.
  - Tasten: `pbc.pressed_up/down/left/right/center/a/b()` (True, solange
    gedrückt), `pbc.was_pressed_up/…/a/b()` (einmal pro Druck),
    `pbc.any_pressed()`, `pbc.wait_for_button()`.
  - LEDs und Ton: `pbc.led_red(an)`, `pbc.led_yellow(an)`, `pbc.led_green(an)`,
    `pbc.leds_off()`, `pbc.rgb_led(r, g, b)`, `pbc.rgb_led_off()`,
    `pbc.tone(hz)`, `pbc.tone(hz, ms)` (wartet nicht!), `pbc.tone_off()`.
  - Sensor: `pbc.accel_x()`, `pbc.accel_y()`, `pbc.accel_z()` (m/s²),
    `pbc.accel_x_g()` usw. (in g). +x nach rechts, +y nach unten.
  - Flimmerfrei: `c = pbc.Canvas(240, 280)`, darauf `c.fill`, `c.pixel`,
    `c.line`, `c.fill_rect`, `c.rect(x, y, b, h, farbe, True)` (beim Canvas
    ohne `fill=`), `c.ellipse(mx, my, rx, ry, farbe, True)`, `c.text`,
    `c.text12/18/24`; anzeigen mit `pbc.show(c)`.
  - Sprites: `s = pbc.sprite("bild.png")` (zuerst unsichtbar), `s.show()`,
    `s.hide()`, `s.set_to(x, y)`, `s.set_by(dx, dy)`, `s.touches(anderes)`,
    `s.touches_edge()`, `s.x`, `s.y`, `s.width`, `s.height`.
  - Turtle: `t = turtle.Turtle()`, `forward`, `back`, `left`, `right`,
    `penUp`, `penDown`, `setPenColor(farbe)`, `speed(0 bis 10)`, `hide()`.
- MicroPython, nicht das große Python: kein pygame, kein tkinter.
- Texte auf dem Display ohne ä, ö, ü und ß (ae, oe, ue, ss schreiben).
- Animationen: in einen Canvas zeichnen, `pbc.show(c)`, kurz warten
  (z. B. `pbc.delay(30)`), in einer Schleife.
- Bilder müssen erst im Studio unter „Dateien → Bilder verwalten…“
  hochgeladen werden. Wenn möglich, mit Rechtecken und Kreisen zeichnen.

## So antwortest du
- In kleinen Schritten, jedes Mal das vollständige Programm, das sich direkt
  ins PBC+ Studio kopieren und mit „Testen“ ausführen lässt.
- Kurze Kommentare auf Deutsch, danach in einfachen Worten erklären, was neu ist.
- Wenn etwas unklar ist, frag nach, statt zu raten.

Arduino

Mit den Bibliotheken aus dem Arduino-Handbuch: Adafruit ST7789/GFX, Adafruit NeoPixel und der eigenen Bibliothek für den Beschleunigungssensor (STK8BA58.zip). Ein Agent mit arduino-cli liefert die fertige .uf2.

# Hinweise für KI-Assistenten (Codex, Claude Code und andere)

Die Sketches in diesem Ordner sind für den **PicoBoy Color Plus** (PBC+) und
die **Arduino IDE 2**. Sie stammen aus dem Buch „Programmieren mit Arduino –
PicoBoy Color Plus“. Der Mensch am anderen Ende lernt gerade programmieren:
Erkläre Änderungen in einfachen Worten.

## Hardware und Board

- Mikrocontroller **RP2350** (wie Raspberry Pi Pico 2), 2 Kerne, 150 MHz,
  520 KB RAM, 16 MB Flash. **Kein** AVR, **kein** Arduino Uno, **kein** ESP32.
- Kern „Raspberry Pi Pico/RP2040/RP2350“ von Earle Philhower (arduino-pico),
  Board **Generic RP2350**, Flash Size **16MB (Sketch: 8MB, FS: 8MB)**.
  FQBN: `rp2040:rp2040:generic_rp2350:flash=16777216_8388608`
- Display ST7789, **240 × 280 Pixel**, (0, 0) oben links, runde Ecken
  (etwa 20 Pixel Rand freilassen).
- Joystick (hoch, runter, links, rechts, Mitte), Tasten A und B, LEDs
  rot/gelb/grün, eine RGB-LED (für Adafruit NeoPixel), Lautsprecher, Beschleunigungssensor
  STK8BA58, zwei AAA-Batterien.

## Pins (immer diese Namen und Nummern)

```cpp
#define TFT_CS 10
#define TFT_DC 8
#define TFT_RST 9
#define TFT_LICHT 26      // Hintergrundlicht
#define LAUTSPRECHER 15
#define LED_ROT 14
#define LED_GELB 13
#define LED_GRUEN 12
#define RGB_LED 11
#define TASTE_HOCH 4
#define TASTE_RUNTER 2
#define TASTE_LINKS 3
#define TASTE_RECHTS 1
#define TASTE_MITTE 0
#define TASTE_A 27
#define TASTE_B 28
#define BATTERIE A3       // Batteriespannung, Spannungsteiler 1:3
```

Benutze nur diese Pins. `LED_BUILTIN` (GP25) ist keine der LEDs.

## Bibliotheken

Nur diese, nichts anderes installieren oder einbinden:

Installation (einmal):

- Adafruit ST7735 and ST7789 und Adafruit NeoPixel aus dem Bibliotheksverwalter
  (`arduino-cli lib install "Adafruit ST7735 and ST7789 Library" "Adafruit NeoPixel"`,
  Adafruit GFX kommt als Abhängigkeit mit).
- STK8BA58 gibt es nicht im Bibliotheksverwalter. Herunterladen:
  https://pbcplus.de/downloads/STK8BA58.zip – in der IDE über
  „Sketch → Bibliothek einbinden → .ZIP-Bibliothek hinzufügen…“, mit arduino-cli:
  `arduino-cli config set library.enable_unsafe_install true` und
  `arduino-cli lib install --zip-path STK8BA58.zip`.

- **Adafruit ST7735 and ST7789** (mit Adafruit GFX): `#include <Adafruit_ST7789.h>`,
  `Adafruit_ST7789 tft(TFT_CS, TFT_DC, TFT_RST);`, `tft.init(240, 280);`
- **Adafruit NeoPixel**: `Adafruit_NeoPixel rgb(1, RGB_LED, NEO_GRB + NEO_KHZ800);`,
  nach `setPixelColor` immer `rgb.show()`.
- **STK8BA58** (Beschleunigungssensor): `sensor.begin(20, 21);` und
  `sensor.setOrientation(STK8BA58::PICOBOY_COLOR_PLUS);`,
  dann `sensor.readAcceleration(x, y, z)` in g.
- Aus dem Kern: `Wire`, `EEPROM`, `LittleFS`, `tone`, `analogRead` usw.

Erfinde keine Funktionen. Wenn du nicht sicher bist, ob es eine Funktion
gibt, lies die Header-Datei der Bibliothek (z. B. `Adafruit_GFX.h`) oder
sag, dass du es nicht weißt.

## Regeln für jeden Sketch

- Arduino-Aufbau: `setup()` und `loop()`, kein eigenes `main()`.
- Display: nach `tft.init(240, 280);` immer das Hintergrundlicht einschalten:
  `pinMode(TFT_LICHT, OUTPUT); digitalWrite(TFT_LICHT, HIGH);` – sonst
  bleibt alles schwarz.
- Flimmerfrei mit `GFXcanvas16 bild(240, 280);` zeichnen und mit
  `tft.drawRGBBitmap(0, 0, bild.getBuffer(), 240, 280);` zeigen.
- Tasten: `pinMode(…, INPUT_PULLUP)`, gedrückt ist `LOW`. Entprellen selbst
  machen.
- I2C: **niemals** `Wire.begin()` ohne vorher die Pins zu setzen. Die
  Standard-Pins GP4/GP5 sind Joystick-Hoch und ein freier Pin. Richtig:
  `Wire.setSDA(20); Wire.setSCL(21); Wire.begin();` oder einfach
  `sensor.begin(20, 21)`. Der Sensor hat die Adresse 0x18.
- **`Serial1` nie benutzen** (liegt auf GP0/GP1 = Joystick Mitte/Rechts),
  `Serial2` auch nicht (GP8/GP9 = Display). Ausgaben über `Serial` (USB),
  `Serial.begin(115200);` als erste Zeile in `setup()`.
- **Keine AVR-Register** wie `PORTB`, `DDRB`, `PIND`, kein `_delay_ms`,
  keine `avr/…`-Header außer dem, was der Kern selbst mitbringt.
- Interrupts (`attachInterrupt`): Die Routine ist kurz, setzt nur
  `volatile`-Variablen. **Kein `delay`, kein `Serial`, kein `tone`, kein
  Zeichnen in einer ISR.**
- Zweiter Kern: `setup1()`/`loop1()`. Nur ein Kern zeichnet auf dem Display.
  Daten zwischen den Kernen über `volatile`-Variablen oder `rp2040.fifo`.
- Texte auf dem Display und im seriellen Monitor ohne Umlaute und ß
  („Schoen“, „Gruesse“).
- Zufall: `randomSeed(rp2040.hwrand32());` in `setup()`.
- Flash schonen: `EEPROM.commit()` und Dateien in `LittleFS` nur schreiben,
  wenn sich etwas geändert hat, nicht in jedem `loop()`-Durchlauf.
- Namen deutsch, klein, ohne Umlaute; 4 Leerzeichen Einrückung; immer
  geschweifte Klammern.

## Prüfen

Der Sketch muss **ohne Fehler und ohne Warnungen** übersetzen. Wenn
`arduino-cli` installiert ist:

```
arduino-cli compile -b rp2040:rp2040:generic_rp2350:flash=16777216_8388608 --warnings all <Sketchordner>
```

Mit `--output-dir build` legt arduino-cli dort auch die fertige `.uf2` ab. Hochladen macht der Mensch (Arduino IDE: **Hochladen**, oder die `.uf2` im Bootmodus aufs Laufwerk ziehen). Was du nicht selbst
testen konntest (Display, Ton, Tasten), nenne ausdrücklich, damit es am Gerät
geprüft wird.

C/C++ mit dem Pico SDK

Für Agenten: alle Hardware-Angaben – Pins, Display, Ton, Sensor, Speicher –, ohne Bibliothek. Der Agent entwickelt direkt mit dem Pico SDK und liefert die fertige .uf2. Wer lieber mit der Buchbibliothek pbc arbeitet, nimmt die Vorlage pbc-vorlage.zip: Sie bringt ihre eigene AGENTS.md mit.

Du entwickelst Programme für den PicoBoy Color Plus (PBC+), einen kleinen
Handheld (63 x 36 mm). Entwickle in C mit dem Raspberry Pi Pico SDK (2.2)
und CMake. Ergebnis ist eine .uf2-Datei, die der Mensch aufspielt.

## Mikrocontroller und Build
- RP2350 (Bauform A, 30 GPIOs), zwei Kerne ARM Cortex-M33, 150 MHz,
  520 KB SRAM, 16 MB Flash (QSPI, ab 0x10000000 eingeblendet).
  Nur einfach genaue FPU: double läuft in Software.
- CMake: PICO_PLATFORM rp2350-arm-s, PICO_BOARD pico2,
  PICO_FLASH_SIZE_BYTES=16777216 (das pico2-Boardfile meldet nur 4 MB),
  PICO_STACK_SIZE=0x1000 (Stack nur 4 KB: keine großen lokalen Arrays).
- Die Standard-Pins des Pico 2 passen NICHT: UART auf GP0/GP1 sind Joystick-
  Pins, I2C auf GP4/GP5 trifft „Joystick hoch“, an GP25 ist keine LED.
  pico_enable_stdio_uart nicht einschalten. Nur die Pins unten benutzen.
- Der Flash-Bereich bei 0x10FFFF00 muss frei bleiben (Zusatzblock der SDK-UF2).

## Pinbelegung
- Joystick (aktiv LOW, interner Pull-up): Mitte GP0, rechts GP1, runter GP2,
  links GP3, hoch GP4. Taste A GP27, Taste B GP28 (ebenso aktiv LOW).
- LEDs (aktiv HIGH): grün GP12, gelb GP13, rot GP14.
- RGB-LED SK6805 (WS2812-kompatibel) an GP11: 24 Bit in der Reihenfolge
  Grün, Rot, Blau, 800 kHz, am besten über PIO.
- Lautsprecher an GP15 (PWM-Slice 7, Kanal B) über RC-Tiefpass. Ein
  Rechtecksignal mit 50 % Tastgrad ergibt einen Ton; danach den Pin auf LOW
  legen, nicht auf halber Spannung stehen lassen.
- Display ST7789 an SPI0: SCK GP18, MOSI GP19, CS GP10 (normaler GPIO),
  DC GP8 (LOW = Befehl), RST GP9, Hintergrundlicht GP26 (PWM).
- Beschleunigungssensor STK8BA58 an I2C0: SDA GP20, SCL GP21, 400 kHz,
  Adresse 0x18, Pull-ups auf der Platine. Register: 0x00 Chip-ID,
  0x02..0x07 Achsen x, y, z (je 10 Bit, linksbündig in 16 Bit),
  0x0F Messbereich (0x03 = ±2 g), 0x10 Bandbreite (0x0C = 125 Hz),
  0x11 Betriebsart (0x00 = normal). Der Chip liegt gedreht: Chip-x ist die
  y-Richtung des Geräts, Chip-y die x-Richtung mit umgekehrtem Vorzeichen.
  Gerät: +x nach rechts, +y nach unten (zum Joystick), +z aus dem Display.
- Batteriespannung an GP29 (ADC-Eingang 3) über Teiler 1:3. Strom aus zwei
  AAA-Batterien (zusammen etwa 2,0 bis 3,2 V) oder USB (etwa 5 V gemessen).

## Display
- 240 x 280 Pixel sichtbar, RGB565. Der Controller hat 240 x 320: sichtbar
  sind die Zeilen 20 bis 299 (Y-Versatz +20). Ecken abgerundet: etwa 20 Pixel
  Rand freilassen.
- SPI Modus 0, MSB zuerst; 62,5 MHz angefordert (das SDK stellt 37,5 MHz ein).
- Initialisierung: RST-Puls, SWRESET (150 ms warten), SLPOUT (120 ms),
  COLMOD 0x55, MADCTL 0xC8 (Hochformat, BGR-Bit gesetzt – Rot und Blau im
  RGB565-Wert vertauschen), INVON (IPS-Panel), NORON, DISPON. Danach den
  ganzen 240 x 320 Speicher löschen.
- Ohne Hintergrundlicht auf GP26 bleibt der Schirm schwarz, egal wie richtig
  der SPI-Verkehr ist.
- Ein Vollbildpuffer kostet 240 x 280 x 2 = 134 KB. Das geht, ist aber ein
  Viertel des Speichers; ein Vollbild belegt den SPI-Bus etwa 17 bis 29 ms.

## Fehlersuche
- Es gibt keine serielle Konsole über UART. Für Diagnose die drei LEDs, den
  Lautsprecher oder den Bildschirm benutzen.

## So arbeitest du
- In kleinen Schritten. Nach jedem Schritt bauen (cmake, Warnungen beheben)
  und die .uf2 liefern. Aufspielen macht der Mensch (BOOT halten, RES tippen,
  Datei auf das Laufwerk ziehen).
- Nenne ausdrücklich, was du nicht selbst testen konntest (Bild, Ton, Tasten).
- Erkläre Änderungen in einfachen Worten. Wenn etwas unklar ist, frag nach,
  statt zu raten.

Beispiel 1: Ein Spiel von Grund auf

Ein eigenes kleines Spiel, Schritt für Schritt mit einem Chat-System gebaut – in Python, damit du jedes Zwischenergebnis sofort im Emulator siehst. Beschreib das Spiel so genau wie möglich und bitte ausdrücklich um kleine Schritte.

1. Ein neues Gespräch in ChatGPT, Gemini oder Claude beginnen und als Erstes den Prompt für Python einfügen.
2. Den Prompt unten eingeben. Die KI liefert Schritt 1: nur das Raumschiff.
3. Das Programm ins PBC+ Studio kopieren (Textmodus) und mit Testen im Emulator ausprobieren.
4. Rückmeldung geben: Was klappt, was nicht? Bei einem Fehler die ganze Meldung aus dem Terminal mitschicken. Dann um den nächsten Schritt bitten („Jetzt die Sterne“).
5. So weitermachen, bis das Spiel fertig ist. Jede Fassung, die funktioniert, speichern (Dateien → Auf den Computer…) – dann kannst du jederzeit zurück.

Ich möchte ein Spiel „Sternenfänger“ für den PBC+ bauen:
Unten fliegt ein Raumschiff, das ich mit dem Joystick nach links und rechts
steuere. Von oben fallen Sterne. Fange ich einen, gibt es einen Punkt und einen
kurzen hohen Ton. Verpasse ich drei Sterne, ist das Spiel vorbei: Dann
erscheinen die Punkte, und mit Taste A geht es von vorn los.
Zeichne alles mit Rechtecken und Kreisen, ohne Bilddateien.

Bitte baue das Spiel in Schritten. Fang mit Schritt 1 an: nur das Raumschiff,
das sich mit dem Joystick bewegt und nicht aus dem Bild fährt.
Warte dann auf meine Rückmeldung, bevor du weitermachst.

Beispiel 2: Ein fremdes Spiel portieren

Ein Agent kann viel mehr als Code schreiben: Er holt sich Quelltext selbst von GitHub, richtet die Werkzeuge ein, baut und behebt seine Fehler. Dir bleibt nur, die fertige .uf2 aufzuspielen und auszuprobieren.

Das Beispiel nimmt 2048.c: das Zahlenschiebe-Spiel 2048 als einzelne C-Datei für die Konsole, unter MIT-Lizenz. Klein genug für einen ersten Versuch – und noch nicht auf dem PBC+.

1. Einen leeren Ordner anlegen und den Prompt für das Pico SDK als AGENTS.md hineinlegen.
2. Codex oder Claude Code im Ordner starten und den Prompt unten eingeben.
3. Der Agent fragt nach, bevor er etwas installiert. Danach holt er das Spiel, baut und meldet sich mit der ersten .uf2.
4. Die Datei im Bootmodus aufs Gerät ziehen (Loslegen), ausprobieren, Rückmeldung geben.

Achte auf die Lizenz: Nimm nur Spiele, deren Lizenz das Weitergeben und Ändern erlaubt, und nenne die Vorlage, wenn du dein Ergebnis weitergibst.

Portiere das Spiel 2048 auf den PicoBoy Color Plus. Die Vorlage ist
https://github.com/mevdschee/2048.c – eine einzige C-Datei für die Konsole
(MIT-Lizenz). Hol sie dir selbst.

Richte dir die Werkzeuge selbst ein, falls sie fehlen: Pico SDK 2.2, CMake,
ARM-Compiler (arm-none-eabi-gcc). Frag mich, bevor du etwas installierst.

So soll es aussehen:
- Das 4x4-Spielfeld füllt den Bildschirm, jede Zahl hat ihre eigene Farbe.
- Der Joystick schiebt die Steine, Taste A startet ein neues Spiel.
- Oben stehen die Punkte. Bei 2048 erscheint „Gewonnen!“, wenn nichts mehr
  geht, „Game over“.
- Die Spiellogik aus 2048.c übernimmst du, nur Ein- und Ausgabe ersetzt du.

Arbeite in Schritten: zuerst ein Testprogramm, das nur das leere Spielfeld
zeichnet, dann die Steine, dann die Steuerung. Liefere nach jedem Schritt die
fertige .uf2 und sag mir, worauf ich beim Ausprobieren achten soll.
Schreib in die README, dass das Spiel auf 2048.c (MIT) beruht.

Prüfen, was die KI schreibt

KI-Code hat typische Fehler. Wer sie kennt, findet sie schnell:

• Arduino statt Pico SDK. Für Mikrocontroller gibt es im Netz sehr viel Arduino-Code. setup, loop, pinMode, delay gibt es im Pico SDK nicht.
• Falsche Pins. Viele Beispiele sind für den Raspberry Pi Pico 2 geschrieben. Dessen Standard-Pins passen nicht: an GP25 hängt keine LED, GP4 ist „Joystick hoch“. Der Compiler merkt das nicht – vergleiche mit der Pinbelegung im System-Prompt.
• Zu viel auf dem Stack. Der Stack hat nur 4 KB. Ein großes Array als lokale Variable baut ohne Warnung, hält das Programm aber beim Start an.
• Code, der fast stimmt. < statt <=, eine vergessene Grenze, ein Wert, der beim Neustart nicht zurückgesetzt wird. Das findest du nur durch Ausprobieren und Lesen.

So prüfst du: Ausprobieren – auch die Ränder: ganz links, ganz rechts, Taste gedrückt halten, sehr schnell drücken. Lesen – verstehst du jede Zeile? Wenn nicht, frag die KI nach einer Erklärung, bevor du weitermachst. Ändern – kannst du selbst eine Kleinigkeit ändern, etwa die Geschwindigkeit? Dann hast du den Code verstanden.

Fair und sicher

• Keine persönlichen Daten. Was du in ein Chat-System tippst, geht an den Anbieter und kann dort gespeichert werden: keine Namen, Adressen, Fotos, Passwörter.
• Mindestalter beachten. Viele Dienste haben ein Mindestalter oder verlangen bei Jüngeren das Einverständnis der Eltern. In der Schule gilt, was die Schule erlaubt.
• KI-Hilfe angeben. Ein Programm von der KI als eigene Arbeit abzugeben, ist in einer Prüfung Täuschung. Gib an, wofür du KI benutzt hast.
• Nur abgeben, was du erklären kannst. In einer Prüfung ohne KI hilft dir nur, was du selbst verstanden hast.