Warum sich JSON, Python und SQL‑Grundkenntnisse beim Arbeiten mit KI lohnen

Dieser Beitrag wurde mit Unterstützung (m)eines KI‑Assistenzsystems erstellt und redaktionell überarbeitet.

Du kannst mit KI in natürlicher Sprache sprechen – aber schon wenige Grundkenntnisse in JSON, Python und SQL machen deine Anweisungen präziser und die Ergebnisse prüfbarer. JSON strukturiert Aufgaben, Python automatisiert kleine Schritte, SQL stellt klare Fragen an Daten. Ein praxistaugliches Vorgehen ist:

(1) in Alltagssprache formulieren

(2) von der KI in JSON übersetzen lassen

(3) Interpretation prüfen und ggf. verfeinern.

Warum überhaupt Programmier‑Basics, wenn KI doch „Sprache versteht“?

Natürliche Sprache ist flexibel – aber oft mehrdeutig. Kleine Syntax‑Bausteine helfen, Interpretationsspielraum zu reduzieren. Mit JSON, Python und SQL kannst du:

Spezifizieren, was genau geliefert werden soll (Struktur, Felder, Umfang).
Validieren, ob das Ergebnis zur Aufgabe passt (Schema, Typen, Tests).
Reproduzieren, also denselben Prozess später wiederholen.

Drei Mini‑Sprachen für den KI‑Alltag

JSON – die Struktur‑Sprache für klare Aufträge

Ideal, um Aufgabenbeschreibungen und Ergebnisschemas festzuhalten.
Menschen‑ und maschinenlesbar, überall einsetzbar.

Beispiel‑Schema (Ergebnis als To‑do‑Liste):

{
  "ziel": "Referat vorbereiten",
  "zeitbudget_min": 60,
  "schritte": [
    { "nr": 1, "titel": "Thema eingrenzen", "dauer_min": 10 },
    { "nr": 2, "titel": "3 Quellen finden", "dauer_min": 20 },
    { "nr": 3, "titel": "Storyline entwerfen", "dauer_min": 15 },
    { "nr": 4, "titel": "Sprechtext skizzieren", "dauer_min": 15 }
  ],
  "lieferformat": "Tabelle"
}

Python – die Schweizer Messer‑Automatisierung

Perfekt für kleine Daten‑ und Textschritte: Listen filtern, Dateien zusammenführen, Ergebnisse prüfen.

Beispiel (Ergebnisliste in eine Tabelle verwandeln):

import json
from pprint import pprint

raw = '''{
  "ziel": "Referat vorbereiten",
  "zeitbudget_min": 60,
  "schritte": [
    { "nr": 1, "titel": "Thema eingrenzen", "dauer_min": 10 },
    { "nr": 2, "titel": "3 Quellen finden", "dauer_min": 20 },
    { "nr": 3, "titel": "Storyline entwerfen", "dauer_min": 15 },
    { "nr": 4, "titel": "Sprechtext skizzieren", "dauer_min": 15 }
  ]
}'''

plan = json.loads(raw)

# Verifizierung: Summe der Dauer
gesamt = sum(s["dauer_min"] for s in plan["schritte"])
assert gesamt <= plan["zeitbudget_min"], "Zeitbudget überschritten!"

pprint(plan["schritte"])

SQL – präzise Fragen an strukturierte Daten

Wenn deine KI Zugriff auf Tabellen/CSV/DB hat (oder du eine Tabelle beilegst), hilft SQL, exakte Auswahlbedingungen zu formulieren.

Beispiel (Kurse filtern):

SELECT kursname, ects, note
FROM leistungen
WHERE semester = 'WiSe' AND ects >= 5 AND note <= 2.3
ORDER BY note ASC;

Empfohlenes Vorgehen: in drei Schritten zur Klarheit

(1) Erst natürlich formulieren
Erkläre in wenigen Sätzen, was du brauchst und warum.

(2) Die KI bitten, daraus JSON zu machen
So siehst du, wie die KI deine Angaben interpretiert – fast wie eine „maschinelle Zusammenfassung“.

(3) Prüfen & verfeinern
Stimmt das Schema? Fehlen Felder? Passen Typen (Zahl/Text/Datum)? Danach ggf. Python/SQL einsetzen, um Ergebnisse zu testen oder Daten auszuwerten.

Praxisbeispiel: Von Alltagssprache zu JSON zu Ergebnis

Schritt A – Alltagssprache
„Erstelle mir für mein 10‑minütiges Referat zur KI in der Berufsbildung einen knappen Plan mit 4 Schritten, der in 60 Minuten Vorbereitung machbar ist. Bitte gib am Ende eine Tabelle für die Schritte aus.“

Schritt B – JSON‑Spezifikation (von der KI erzeugt, von dir geprüft)

{
  "rolle": "Studiencoach",
  "thema": "KI in der Berufsbildung",
  "zeitbudget_min": 60,
  "anzahl_schritte": 4,
  "ausgabe": {
    "typ": "tabelle",
    "spalten": ["nr", "titel", "dauer_min"]
  },
  "restriktionen": [
    "Gesamtdauer <= zeitbudget_min",
    "Sprache B2",
    "keine erfundenen Quellen"
  ]
}

Schritt C – Ergebnis prüfen/weiterverarbeiten (Python)

# Angenommen, die KI liefert eine JSON-Liste "schritte" zurück:
from statistics import mean

schritte = [
  {"nr":1, "titel":"Thema eingrenzen", "dauer_min":10},
  {"nr":2, "titel":"Quellen finden", "dauer_min":20},
  {"nr":3, "titel":"Storyline entwerfen", "dauer_min":15},
  {"nr":4, "titel":"Sprechtext skizzieren", "dauer_min":15}
]

gesamt = sum(s['dauer_min'] for s in schritte)
mittig = mean(s['dauer_min'] for s in schritte)
print("Gesamtdauer:", gesamt)
print("Durchschnitt pro Schritt:", round(mittig,1))

Häufige Stolpersteine – und wie du sie vermeidest

Mehrdeutige Begriffe: Definiere Felder/Spalten im JSON (Schema zuerst).
Halluzinierte Spalten/Quellen: Gib der KI das bekannte Schema (Spaltennamen) bzw. verlange „nur Felder aus diesem Schema“.
Unstete Ergebnisse: Bitte um valide JSON‑Antworten (kein Markdown, keine Kommentare) – so kannst du automatisch prüfen.
Daten‑Fehler: Nutze kurze Python‑Checks (Summe, Min/Max, Eindeutigkeit).
Unklare Datenfragen: Formuliere die Bedingung einmal in Deutsch und nochmal in SQL – Unterschiede fallen auf.

Prompt‑Bausteine für stabile Ausgaben:

Gib die Antwort als **valide JSON** ohne Kommentare.
Nutze **genau diese Felder**: [feld1, feld2, ...].
Wenn unsicher, **frage zurück**, bevor du annimmst.
Nenne **Unsicherheiten** am Ende unter "unsicherheiten": [...].

Mini‑Übung (15–20 Min.)

Aufgabe: Formuliere eine Studienaufgabe (z. B. „Literaturüberblick in 5 Bulletpoints“).
1. Schreibe sie in Alltagssprache.
2. Bitte die KI: „Forme das in JSON um, inkl. Ergebnis‑Schema.“
3. Prüfe das JSON (Felder, Typen, Bedingungen).
4. Lasse dir das Ergebnis erzeugen und validiere mit einem Mini‑Python‑Check (z. B. Längen, Summen).
5. (Optional) Wenn Daten im Spiel sind: Formuliere eine äquivalente SQL‑Abfrage.

Reflexionsfragen:

Wo wurden Missverständnisse sichtbar, als du das JSON gesehen hast?
Welche Felder/Regeln haben den größten Unterschied gemacht?
Was würdest du beim nächsten Mal direkt als Schema vorgeben?

Checkliste: Bin ich startklar?

Ich kenne die Grundidee von JSON (Schlüssel‑Wert, Listen, Typen).
Ich kann einen Python‑Snippet ausführen (z. B. zur Validierung).
Ich weiß, wie ich eine SQL‑Bedingung für meine Daten formuliere.
Ich fordere valide JSON‑Antworten von der KI an.
Ich dokumentiere Prompt + JSON‑Schema + Ergebnis.

Zum Mitnehmen

Natürliche Sprache reicht oft – aber ein Hauch Struktur macht dich schneller und sicherer. Mit JSON reduzierst du Missverständnisse, mit Python prüfst und automatisierst, mit SQL stellst du präzise Datenfragen. So arbeitet die KI für dich – nicht an dir vorbei. Best of both worlds! Wer KI mit dem richtigen Mix aus natürlicher Sprache und Code steuert, wird am meisten davon profitieren.

Der KI Kompass für Studierende