Mein 12-jähriger Sohn und Claude Code: „Da lernt man nichts“?

Eine Antwort an erfahrene Programmierer, die Vibe-Coding unterschätzen – mit Bloom’s Taxonomy und konkreten Beispielen

Die Kritik: „Mit Vibe-Coding lernt man nichts“

Das höre ich ständig von erfahrenen Programmierern, ich überspitze mal. „Dein 12-jähriger Sohn soll richtig programmieren lernen, nicht mit so einem Tool rumspielen. Da lernt er doch nichts!“ Die Lua Datei die Claude Code gebaut hat ist am Ende des Scripts, ich weiss aber im Moment nicht ob es die letzte Version ist.

Bloom’s Taxonomy: Wie lernt man eigentlich richtig? (ich weiss Blooms Ansatz ist ein Modell und nicht die Wahrheit)

Bevor ich antworte, schauen wir uns an, wie Lernen nach der Wissenschaft funktioniert.

Bloom’s Taxonomy definiert sechs aufeinander aufbauende Lernstufen:

1. Remember (Erinnern): Begriffe und Fakten lernen

• Beispiel: Was ist eine Variable? Was bedeutet „Shell“?

2. Understand (Verstehen): Zusammenhänge begreifen

• Beispiel: Warum braucht man Variablen? Wie hängen Shell und System zusammen?

3. Apply (Anwenden): Gelerntes praktisch nutzen

• Beispiel: Eine Variable erstellen. Shell-Befehle ausführen.

4. Analyze (Analysieren): Strukturen erkennen und zerlegen

• Beispiel: Code-Architektur verstehen. Probleme systematisch untersuchen.

5. Evaluate (Bewerten): Qualität und Alternativen beurteilen

• Beispiel: „Ist dieser Code gut?“ „Welcher Ansatz ist besser?“

6. Create (Erschaffen): Neues eigenständig entwickeln

• Beispiel: Eigene Programme schreiben. Innovative Lösungen entwickeln.

Achtung, wenn ich von „Lernen“ weiter unten spreche, meine ich Die Ebenen 1-3

Das entscheidende Problem: Man kann keine Stufen überspringen

Erfahrene Programmierer vergessen: Man kann nicht von Stufe 1 direkt zu Stufe 6 springen. Jede Stufe baut auf der vorherigen auf.

❌ Falsch: „Lern erstmal richtig C++, dann kannst du programmieren!“ ✅ Richtig: Lass ihn durch alle Stufen gehen – von Begriffen über Verstehen bis zum Anwenden.

Meine Antwort: Vibe-Coding folgt perfekt der Bloom’s Taxonomy

Ich bin froh, dass mein 12-Jähriger mit Claude Code die richtige Lernreihenfolge durchläuft!

Er installierte Claude Code selbst. Gestern wieder: Pfade nicht in der Shell konfiguriert. 20 Minuten Fehlersuche für einen „einfachen“ Pfad-Fehler. Aber dabei hat er enorm viel gelernt!

Als erstes hat mein Sohn ein Kapitel aus diesem Online-Kurs sich zu Claude Code angeschaut

Das sind die Ergebnisse, ihr seht „Versionierung funktioniert noch nicht so ganz“

Konkrete Beispiele aus seinem ersten Claude Code Projekt:

Bloom’s Taxonomy in Action: Was mein Sohn wirklich lernte

Stufe 1 – Remember (Erinnern): Ein 12-Jähriger lernt wichtige Begriffe

Shell & System-Grundlagen:

• Was ist eine Shell überhaupt?
• Shell-Befehle: cd, mkdir, ls, nano
• Begriffe: npm, nvm, config, PATH-Variablen
• Globale vs. lokale Variablen

Claude Code Entwicklungskonzepte:

• CLAUDE.md-Datei (Projektdokumentation)
• Init-Befehle (Projekt starten)
• Memory-Befehle (Kontext speichern)
• Planungsmodus (vor dem Coden planen)
• Versionierung (automatische Backups)
• Repository-Struktur (Dateien organisieren)

Mein 12-Jähriger lernt 50+ wichtige Begriffe!

Konkrete Beispiele: Was Claude Code für meinen Sohn erstellt hat

1. Projektstruktur und CLAUDE.md verstehen

Claude Code die CLAUDE.md-Datei aus dem Online-Kurs (erstmal sehr einfach):

# CLAUDE.md

This file provides guidance to Claude Code when working with code in this repository.

## Project Status
This is currently an empty project directory with no established codebase.

## Getting Started
When asked to create a new project in this directory, you should:
1. First ask the user what type of project they want to create
2. Initialize the appropriate project structure 
3. Update this CLAUDE.md file with the new project-specific commands

## Claude CLI Configuration
The directory contains Claude CLI settings in `.claude/settings.local.json`

Was mein Sohn dabei lernte:

• Was ist eine Projektdokumentation?
• Wie strukturiert man Code-Repositories?
• Was sind Konfigurationsdateien (settings.local.json)?
• Warum braucht man Projektbeschreibungen?

2. Versionierung und Iteration verstehen

Claude Code versionierte automatisch sein Roblox-Projekt:

• DrunkDealer_v1.lua (erste Version)
• DrunkDealer_v2.lua (Verbesserungen)
• DrunkDealer_ULTIMATE_v3.lua (finale Version)

Header aus v3.0:

--[[
    Drunk Dealer Complete Script v3.0 - ULTIMATE VERSION
    Author: Claude
    Date: 2025-07-08
    
    MAJOR IMPROVEMENTS:
    - Completely redesigned GUI with modern look
    - Properly sized hitboxes matching R15 rig
    - Smooth animations and visual feedback
    - Better collision detection
]]

Was mein Sohn dabei lernte:

• Warum macht man Versionierung (klappt aber noch nicht so)?
• Wie dokumentiert man Änderungen?
• Was sind Iterationen in der Entwicklung?
• Wie plant man Feature-Updates?

3. Code-Organisation und Architektur

Claude Code teilte automatisch Server- und Client-Code auf:

--[[
====================================================================================
SECTION 1: SERVER SCRIPT - COPY THIS TO ServerScriptService
====================================================================================
]]

-- Drunk Dealer Server Script v3.0
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- ... komplexer Server-Code

--[[
====================================================================================
SECTION 2: CLIENT SCRIPT - COPY THIS TO StarterPlayer > StarterPlayerScripts
====================================================================================
]]

-- Drunk Dealer Client Script v3.0 - Modern GUI
local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")
-- ... komplexer Client-Code

Was mein Sohn dabei lernte:

• Was ist Client-Server-Architektur?
• Warum trennt man Server- und Client-Code?
• Was sind Services in Roblox?
• Wie organisiert man große Code-Projekte?

4. Professionelle Dokumentation schreiben

Claude Code generierte automatisch eine README-Datei:

# Betrunkener Waffenhändler - Setup Guide

## Installation
1. **ServerScript** (`DrunkDealerServer.lua`)
   - Platziere diese Datei in `ServerScriptService`

2. **LocalScript** (`DrunkDealerClient.lua`)  
   - Platziere diese Datei in `StarterPlayer > StarterPlayerScripts`

## Features
- **Betrunkener NPC** der durch die Map wandert
- **Waffenshop** mit 5 verschiedenen Waffen
- **Interaktives GUI** (Drücke F zum Öffnen)

## Anpassungen
- **Geschwindigkeit**: `WALK_SPEED = 4` (Zeile 33)
- **Interaktionsdistanz**: `INTERACTION_DISTANCE = 15` (Zeile 34)

Was mein Sohn dabei lernte:

• Wie schreibt man Installations-Anleitungen?
• Was sind Features und wie dokumentiert man sie?
• Wie macht man Code konfigurierbar?
• Warum sind README-Dateien wichtig?

Stufe 2 – Understand (Verstehen): Zusammenhänge begreifen

Mein Sohn versteht langsam die Zusammenhänge:

Komplexe Programmierkonzepte verstehen

Aus dem generierten Lua-Code lernte er:

-- Configuration (Konfiguration am Anfang)
local SPAWN_POSITION = Vector3.new(0, 10, 0)
local NPC_SCALE = 1.3
local INTERACTION_DISTANCE = 25
local WALK_SPEED = 4

-- Weapons (Datenstrukturen)
local WEAPONS = {
    {name = "Pistole", price = 100, toolName = "Pistol", damage = 20},
    {name = "Schrotflinte", price = 500, toolName = "Shotgun", damage = 50},
    {name = "Raketenwerfer", price = 5000, toolName = "RocketLauncher", damage = 200}
}

Was er versteht:

• Warum sammelt man Konfiguration am Anfang?
• Was sind Datenstrukturen (Arrays, Objects)?
• Wie macht man Code wartbar und lesbar?
• Warum benutzt man Konstanten statt Magic Numbers?

GUI und User Experience Konzepte

Aus dem GUI-Code versteht er:

-- UI Colors (Design-System)
local COLORS = {
    Background = Color3.fromRGB(20, 20, 20),
    Primary = Color3.fromRGB(255, 170, 0),
    Secondary = Color3.fromRGB(40, 40, 40),
    Success = Color3.fromRGB(0, 255, 0),
    Error = Color3.fromRGB(255, 0, 0)
}

-- Hover effects (Interaktivität)
weaponCard.MouseEnter:Connect(function()
    TweenService:Create(weaponCard, TweenInfo.new(0.2), {
        BackgroundColor3 = Color3.fromRGB(60, 60, 60)
    }):Play()
end)

Was er versteht:

• Warum braucht man Design-Systeme?
• Was macht gute User Experience aus?
• Wie funktionieren Animationen und Feedback?
• Warum sind Hover-Effekte wichtig?

Gestern: 20 Minuten Fehlersuche für Pfad-Problem. Das zeigt echter Lernfortschritt: Er will verstehen, warum Dinge nicht funktionieren, statt nur Befehle nachzutippen.

Stufe 3 – Apply (Anwenden): Erste praktische Versuche

Mein Sohn probiert praktische Anwendung:

System-Administration

• Directories wechseln (klappt schon)
• Config-Dateien bearbeiten (noch schwierig)
• Init-Befehle ausführen (manchmal erfolgreich)
• CLAUDE.md-Datei schreiben (experimentiert damit)

Game Development Konzepte anwenden

Er experimentiert mit dem generierten Code, hier will er Variablen setzen, er versteht natürlich nicht alles, dennoch sind die Schlüsselbegriffe klar (while, local randomPos…):

-- NPC Behavior (Verhalten programmieren)
local function wanderAroundMap(npc)
    local humanoid = npc:FindFirstChild("Humanoid")
    spawn(function()
        while npc.Parent and humanoid.Parent do
            local randomPos = npc.PrimaryPart.Position + Vector3.new(
                math.random(-15, 15), 0, math.random(-15, 15)
            )
            humanoid:MoveTo(randomPos)
            wait(math.random(5, 10))
        end
    end)
end

Was er anwendet:

• Parameter in Funktionen ändern (math.random(-15, 15))
• Spawn-Positionen anpassen (SPAWN_POSITION)
• Waffen-Preise modifizieren (price = 100)
• NPC-Verhalten experimentieren (WALK_SPEED)

Debugging und Problem-Solving

Typische Probleme, die er löst:

• „Warum spawnt der NPC nicht?“ → SPAWN_POSITION verstehen
• „Warum ist die GUI zu klein?“ → UI-Scaling lernen
• „Warum kauft der Shop nicht?“ → Client-Server-Communication
• „Warum läuft der NPC so schnell?“ → WALK_SPEED Parameter

Die unterschätzte Realität: Echte Entwicklungs-Skills

Diese Grundlagen sind überall wertvoll:

Universelle Programmierprinzipien

• Versionierung ist ein Profi-Konzept (Git, Software-Releases)
• Dokumentation (README, Code-Comments) ist beste Praxis
• Code-Organisation (Trennung, Module) findet man überall
• Konfiguration (Constants, Settings) ist Standard
• Client-Server-Architektur ist fundamental

Moderne Entwicklungsworkflows

• Projektstruktur mit CLAUDE.md entspricht modernen Standards
• Feature-Planning durch Planungsmodus
• Iterative Entwicklung durch Versionierung
• User Experience Design durch GUI-Konzepte
• Error Handling und Debugging-Mindset

Game Development als Einstieg

• 3D-Mathematik (Vector3, CFrame, Positioning)
• Event-System (RemoteEvents, Client-Server)
• Animation (TweenService, UI-Transitions)
• State Management (Player-Data, Shops, Inventory)
• Performance (Efficient Loops, Memory Management)

Fazit: Mein Sohn lernt schrittweise echte Entwicklungsgrundlagen

Mein 12-Jähriger arbeitet sich durch Bloom’s Taxonomy (Shell-Begriffe, Debugging-Mindset, Claude Code Workflows, Game Development, Client-Server-Architektur, Versionierung, Projektdokumentation) – und Kritiker sagen „da lernt man nichts“?

Die Wahrheit: Vibe-Coding mit Claude Code vermittelt fundamentale Entwicklungskonzepte durch praktische, sofort sichtbare Projekte. Mein Sohn lernt nicht nur „Programmieren“ – er lernt afud dem Weg professionelle Softwareentwicklung (ja das ist ein längerer Weg, macht aber so um mehr Freude).

Liebe erfahrene Programmierer: Schaut genauer hin. Was hier passiert, ist der perfekte Einstieg in eure Welt.