Wie man in 6 Monaten AI Engineer wird (RESSOURCEN)

KI-Technik zählt mittlerweile zu den wertvollsten Fähigkeiten im Tech-Bereich

Das Problem: Die meisten Anfänger haben keine klare Vorstellung davon, was sie eigentlich lernen sollten

Manche starten mit der Theorie des maschinellen Lernens

Andere verlieren sich in Endlos-Tutorials

Wieder andere stürzen sich direkt auf Prompts und Agenten, ohne APIs, Backend-Grundlagen oder die tatsächliche Entwicklung von Produkten zu verstehen

Das Ergebnis ist meist das gleiche: jede Menge Verwirrung und kaum praktische Fertigkeiten

Wenn du KI-Ingenieur werden willst, musst du nicht jedes Feld der künstlichen Intelligenz meistern

Du musst lernen, wie man in der realen Welt nützliche KI-Systeme baut

Das bedeutet zu lernen, wie man:

• durchgängige Anwendungen mit LLMs entwickelt
• mit Modell-APIs wie OpenAI und Anthropic arbeitet
• Prompts und Kontext richtig gestaltet
• strukturierte Ausgaben und Tool-Funktionen nutzt
• bei Bedarf Retrieval einbindet
• Projekte bereitstellt, damit andere sie tatsächlich nutzen können

Dieser Leitfaden bietet dir einen praktischen 6-Monats-Fahrplan

Der Artikel umfasst über 10.000 WÖRTER, das Lesen kann also ein paar Stunden oder sogar länger dauern

Aber sein wahrer Wert liegt darin, dass es für jede Fähigkeit, die du lernen musst, Ressourcen und klare Erklärungen gibt, was zu tun ist

So kannst du innerhalb von sechs Monaten das Niveau der KI-Entwicklung erreichen und es bereits in den ersten 1-2 Monaten für dich selbst nutzen

Ich habe mehr als 40 STUNDEN an diesem Artikel gearbeitet, und zwar zusammen mit meinem Freund @andy_ai0

Er baut gerade seine persönliche Marke auf X auf, versteht KI aber sehr gut und hat viel zu diesem Artikel beigetragen

Ich finde, er verdient auf jeden Fall deine Unterstützung, während er wächst

Jetzt lass uns mit dem Artikel beginnen ⬇️

Was ein KI-Ingenieur eigentlich macht

Viele Leute hören den Begriff "KI-Ingenieur" und stellen sich jemanden vor, der riesige Modelle von Grund auf trainiert

In der Realität machen die meisten modernen KI-Ingenieure etwas viel Praktischeres

Sie bauen Produkte und Systeme auf der Grundlage vorhandener Modelle

Das beinhaltet in der Regel:

• die Verbindung zu LLM-APIs
• das Design von Prompts und Kontextabläufen
• den Bau von Chat-, Such- oder Automatisierungssystemen
• die Integration von Tools, Datenbanken und externen APIs
• die Handhabung strukturierter Ausgaben
• die Verbesserung von Zuverlässigkeit, Kosten und Latenz
• die Bereitstellung von KI-Funktionen in echten Anwendungen

In der Praxis sitzt ein KI-Ingenieur also oft zwischen:

• Softwareentwicklung
• Produktentwicklung
• Automatisierung
• angewandter KI

Deshalb wächst die Rolle so schnell

Unternehmen brauchen nicht nur Forscher

Sie brauchen Leute, die Modelle nehmen und in nutzbare Produkte verwandeln können

Auch deshalb konzentriert sich dieser Fahrplan weniger auf schwere Theorie und mehr auf praktische Umsetzung

Wenn du echte LLM-Apps, Retrieval-Systeme, Automatisierungen und produktionsreife Workflows bauen kannst, bist du der Anstellung schon viel näher als die meisten Anfänger

⏩------------------------------------------------------------------------⏪

Monat 1: Baue dir solide Grundlagen in Coding und den Grundlagen auf

Dein Ziel diesen Monat: Werde ein funktionaler Python-Entwickler

Du musst kein Experte sein, du musst nur aufhören, grundlegende Syntax zu googeln, und in der Lage sein, einfache Programme sicher zu erstellen

KI-Entwicklung ist in erster Linie Softwareentwicklung

Alles in den späteren Monaten setzt voraus, dass du sauberes Python schreiben, das Terminal nutzen, APIs aufrufen und eine Codebase verwalten kannst. Dieser Monat ist deine Grundlage

Was du lernen solltest

1. Python

Python ist die Sprache der KI-Entwicklung. Punkt. Fast jede Bibliothek, API und jedes Tutorial, das dir in den nächsten sechs Monaten begegnet, ist in Python

Wie du es lernst:

Beginne mit einem strukturierten Kurs, der dich zwingt, Code zu schreiben, nicht nur Videos anzuschauen

Der häufigste Fehler, den Anfänger machen, ist, Inhalte passiv zu konsumieren, mitzulesen, zu nicken und nie einen Code-Editor zu öffnen

Kämpfe dagegen an, indem du jedes einzelne Beispiel beim Lernen selbst codest

Ressourcen:

1. Python für alle (Coursera, kostenlos als Hörer)

Link: https://www.coursera.org/specializations/python

Der beste Einstieg für absolute Anfänger. Dr. Chuck ist einer der anfängerfreundlichsten Python-Lehrer im Internet

2. freeCodeCamp Python Kurs (YouTube, kostenlos)

Link: https://www.youtube.com/watch?v=rfscVS0vtbw

Ein umfassendes 4-stündiges Video, das alle Grundlagen abdeckt

3. CS50P: Einführung in die Programmierung mit Python (Harvard, kostenlos)

Link: https://cs50.harvard.edu/python/

Anspruchsvoller. Enthält Aufgabensets und ein Abschlussprojekt. Großartig, wenn du Struktur magst

4. Offizielle Python-Dokumentation (das Tutorial)

Link: https://docs.python.org/3/tutorial/

Trocken, aber maßgeblich – als Nachschlagewerk nutzen

Worauf du dich konzentrieren solltest:

• Variablen, Datentypen, Schleifen, Bedingungen, Funktionen
• Listen, Dictionaries, Sets, Tupel
• Datei-E/A und Arbeiten mit JSON
• Klassen und grundlegende OOP (gerade genug, um zu verstehen, was du liest)
• Fehlerbehandlung mit try/except
• Virtuelle Umgebungen (venv) und pip
• Paketverwaltung – Verständnis von requirements.txt

Übungsprojekt: Baue ein einfaches CLI-Tool in Python. So etwas wie einen persönlichen Ausgaben-Tracker, der in eine JSON-Datei liest/schreibt, oder ein Skript, das eine öffentliche API (wie eine Wetter-API) aufruft und formatierte Ergebnisse ausgibt

2. Git und GitHub

Git ist die Art und Weise, wie professionelle Entwickler Code speichern und teilen. Du wirst es ständig brauchen, um deine Projekte zu versionieren, zusammenzuarbeiten und deine Portfolio-Arbeit auf GitHub zu präsentieren

Wie du es lernst:

Git ist am Anfang verwirrend, weil das mentale Modell nicht offensichtlich ist

Versuche nicht, Befehle auswendig zu lernen. Verstehe stattdessen, welches Problem Git löst

(Änderungen verfolgen, Zusammenarbeit ermöglichen, Fehler rückgängig machen) und die Befehle werden Sinn ergeben

Ressourcen:

1. GitHub Skills (kostenlos, interaktiv)

Link: https://skills.github.com/

Offizielle interaktive Kurse, die in GitHub selbst integriert sind. Starte hier

2. Git Branching lernen (kostenlos, interaktiv)

Link: https://learngitbranching.js.org/

Das mit Abstand beste visuelle Tool, um Branches und Merges zu verstehen

3. Pro Git Buch (kostenloses Online-Buch)

Link: https://git-scm.com/book/de/v2

Die umfassende Referenz. Überspringe zu den Kapiteln, die du brauchst

Worauf du dich konzentrieren solltest:

• git init, add, commit, push, pull
• Branching und Merging
• Verständnis von .gitignore
• Repos auf GitHub erstellen und lokale Projekte pushen
• Grundlegende README-Dateien lesen und schreiben

Übung: Von jetzt an sollte jedes einzelne Projekt, das du baust, selbst kleine Skripte, in einem GitHub-Repo leben. Das schafft die Gewohnheit und gibt dir ein Portfolio

3. CLI / Terminal-Grundlagen

Als KI-Ingenieur wirst du Skripte ausführen, Pakete installieren, Server verwalten und Dateien ausschließlich über die Kommandozeile navigieren

Langsam oder ängstlich im Terminal zu sein, ist ein echtes Hindernis

Ressourcen:

1. Die 50 wichtigsten Linux- & Terminal-Befehle (vollständiger Kurs für Anfänger)

Link: https://www.youtube.com/watch?v=ZtqBQ68cfJc

Gut für absolute Anfänger auf Linux/Mac

2. Das fehlende Semester deiner CS-Ausbildung (MIT, kostenlos)

Link: https://missing.csail.mit.edu/

Behandelt Shell-Scripting, Terminal-Tools und die Kommandozeilen-Flüssigkeit, die die meisten CS-Kurse auslassen

Worauf du dich konzentrieren solltest:

• Navigation: cd, ls, pwd, mkdir, rm
• Dateien lesen: cat, less, grep
• Python-Skripte vom Terminal aus ausführen
• Umgebungsvariablen
• Grundlegendes Verständnis von PATH

4. JSON, APIs, HTTP und Async-Grundlagen

Du wirst ab dem ersten Tag des zweiten Monats LLM-APIs aufrufen

Das bedeutet, dass du verstehen musst, wie Web-APIs funktionieren, bevor du jemals die SDKs von OpenAI oder Anthropic anfasst

Ressourcen:

1. HTTP-Grundlagen – MDN Web Docs (kostenlos)

Link: https://developer.mozilla.org/de/docs/Web/HTTP/Overview

Die klarste Erklärung, wie HTTP-Anfragen und -Antworten funktionieren

2. REST API Tutorial

Link: https://restfulapi.net/

Kurz und praktisch

3. Python requests Bibliotheksdokumentation

Link: https://requests.readthedocs.io/en/latest/

Lerne, wie man jede Web-API in Python aufruft

4. Python async/await (kostenlos)

Link: https://realpython.com/async-io-python/

Das Verständnis von Async ist unerlässlich für die spätere Arbeit mit Streaming-LLM-Antworten

Worauf du dich konzentrieren solltest:

• GET-, POST-Anfragen – was sie sind und wie man sie in Python stellt
• JSON lesen und schreiben
• HTTP-Statuscodes (200, 400, 401, 404, 500 – was sie bedeuten)
• Was ein API-Key ist und grundlegende Auth-Muster
• Was async def und await tun und warum es sie gibt

Übungsprojekt: Schreibe ein Python-Skript, das eine kostenlose öffentliche API aufruft (versuche es mit Open-Meteo für Wetterdaten – kein API-Key nötig) und das Ergebnis als saubere JSON-Ausgabe formatiert

5. Grundlegendes SQL und Pandas

Du wirst kein Datenwissenschaftler sein müssen, aber du wirst regelmäßig Daten inspizieren, abfragen und manipulieren müssen

SQL-Grundlagen und Pandas-Flüssigkeit werden dir ständig helfen

Ressourcen:

1. SQLBolt (kostenlos, interaktiv)

Link: https://sqlbolt.com/

Der schnellste Weg, SQL von Grund auf zu lernen. 20 kurze Lektionen mit Übungen im Browser

2. Pandas offizieller Einstiegsleitfaden

Link: https://pandas.pydata.org/docs/getting_started/index.html

Arbeite das "10 Minuten zu Pandas"-Tutorial durch

3. Kaggle Pandas Kurs (kostenlos)

Link: https://www.kaggle.com/learn/pandas

Praktisch, anwendungsorientiert, kurz

Worauf du dich konzentrieren solltest:

• SQL: SELECT, WHERE, GROUP BY, JOIN, ORDER BY
• Pandas: CSVs laden, Zeilen filtern, Spalten auswählen, grundlegende Aggregationen

6. FastAPI

Ressourcen:

1. FastAPI Offizielles Tutorial (kostenlos)

Link: https://fastapi.tiangolo.com/de/tutorial/

Ehrlich gesagt eine der besten Framework-Dokumentationen, die je geschrieben wurden

Arbeite es von Anfang bis Ende durch. Behandelt Pfadparameter, Request-Bodies, Pydantic-Validierung und das Ausführen eines Dev-Servers

2. Python API Entwicklung (19-Stunden-Kurs, freeCodeCamp, YouTube, kostenlos)

Link: https://www.youtube.com/watch?v=ZtqBQ68cfJc

Behandelt API-Design-Grundlagen, einschließlich Routen, Serialisierung, Schema-Validierung und SQL-Datenbankintegration. Baut eine vollständige Social-Media-artige API von Grund auf

Worauf du dich konzentrieren solltest: GET- und POST-Endpunkte erstellen, Pfad- und Query-Parameter, Request-Bodies mit Pydantic, uvicorn ausführen und die integrierte /docs-Oberfläche von FastAPI verwenden, um deine API zu testen, ohne einen Client zu schreiben

Meilenstein Monat 1

Am Ende dieses Monats solltest du in der Lage sein:

• Python-Programme zu schreiben, die Dateien lesen/schreiben, APIs aufrufen und Fehler behandeln
• Deinen Code mit Git zu versionieren und Projekte auf GitHub zu pushen
• Das Terminal ohne Zögern zu navigieren
• Zu verstehen, was eine HTTP-Anfrage ist, und eine in Python zu stellen
• Eine SQLite-Datenbank mit grundlegendem SQL abzufragen
• Eine einfache FastAPI-App lokal zu bauen und auszuführen

⏩------------------------------------------------------------------------⏪

Monat 2: Meistere die LLM-App-Entwicklung

Dein Ziel diesen Monat: Baue echte KI-gestützte Anwendungen mit den OpenAI- und Anthropic-APIs

Am Ende solltest du in der Lage sein, zuverlässig funktionierende Prompts zu schreiben, strukturierte Daten aus Modellen zu extrahieren, sie deine Funktionen aufrufen zu lassen und alles zu handhaben, was schiefgehen kann

Das ist der Kern der KI-Entwicklung. Alles andere im Fahrplan baut auf dem auf, was du hier lernst

Was du lernen solltest

1. Grundlagen des Promptings

Prompting bedeutet nicht nur, nett zu fragen. Es ist die Kunst, Anweisungen zu schreiben, die konsistente, zuverlässige Ergebnisse von grundsätzlich probabilistischen Modellen liefern

Als KI-Ingenieur wirst du überraschend viel Zeit hier verbringen

Wie du es lernst:

Beginne mit dem interaktiven Tutorial von Anthropic, weil es am praktischsten ist

Lies dann den offiziellen Leitfaden von OpenAI. Danach fasst der Prompt Engineering Guide alles zusammen

Arbeite alle drei der Reihe nach durch – jeder verstärkt die anderen

Ressourcen:

1. Anthropics Interaktives Prompt Engineering Tutorial (kostenlos, GitHub)

Link: https://github.com/anthropics/prompt-eng-interactive-tutorial

Ein Schritt-für-Schritt-Kurs, aufgeteilt in 9 Kapitel mit Übungen, der dir viele Gelegenheiten gibt, das Schreiben und Troubleshooting von Prompts selbst zu üben

Führe es als Jupyter-Notebooks mit der Claude-API aus

2. Anthropic Prompt Engineering Dokumentation (kostenlos)

Link: https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview

Die offizielle Referenz. Deckt alles von grundlegender Klarheit bis hin zu XML-Strukturierung und agentischen Systemen ab

3. OpenAI Prompt Engineering Leitfaden (kostenlos)

Link: https://platform.openai.com/docs/guides/prompt-engineering

Der offizielle Leitfaden von OpenAI, der Prompt-Formate abdeckt, die gut mit ihren Modellen funktionieren und zu nützlicheren Ausgaben führen

4. PromptingGuide.ai (kostenlos)

Link: https://www.promptingguide.ai/

Behandelt wesentliche Techniken vom einfachen Prompting bis zu fortgeschrittenen Strategien, plus Funktionsaufruf, Tool-Integration und agentische Systeme

Worauf du dich konzentrieren solltest: Der Unterschied zwischen System- und Benutzernachrichten, warum Spezifität wichtig ist, Chain-of-Thought-Prompting (Schritt für Schritt denken), die Verwendung von Beispielen in Prompts (Few-Shot) und wie kleine Änderungen in der Formulierung die Ausgabequalität drastisch verändern können

Übung: Nimm eine reale Aufgabe – fasse ein Dokument zusammen, extrahiere Schlüsselinformationen aus Text, klassifiziere ein Feedback – und schreibe 5 verschiedene Prompts dafür. Vergleiche die Ausgaben. Du wirst sofort sehen, wie sehr das Prompt-Design die Zuverlässigkeit beeinflusst

3. Strukturierte Ausgaben / JSON-Schemas

In echten Anwendungen willst du fast nie Rohtext von einem LLM, sondern strukturierte Daten, die du parsen, speichern und in deinem Code verwenden kannst

Strukturierte Ausgaben lösen dies, indem sie das Modell zwingen, einem von dir definierten Schema zu entsprechen

Ressourcen:

1. OpenAI Leitfaden für Strukturierte Ausgaben (offizielle Dokumentation, kostenlos)

Link: https://platform.openai.com/docs/guides/structured-outputs

Behandelt die Funktion, die sicherstellt, dass Modelle immer Antworten generieren, die deinem JSON-Schema entsprechen, sodass du dir keine Sorgen über fehlende Schlüssel oder halluzinierte Werte machen musst

2. Instructor Bibliothek (kostenlos, Open Source)

Link: https://python.useinstructor.com/

Der sauberste Weg, strukturierte Ausgaben von jedem LLM-Anbieter mit Pydantic-Modellen zu erhalten

Funktioniert mit OpenAI, Anthropic, Google und 15+ anderen Anbietern mit derselben Code-Schnittstelle, mit automatischen Wiederholungsversuchen bei fehlgeschlagener Validierung

Das ist, was die meisten Produktions-KI-Ingenieure tatsächlich verwenden

3. OpenAI Kochbuch: Einführung in Strukturierte Ausgaben (kostenlos)

Link: https://developers.openai.com/cookbook/examples/structured_outputs_intro/

Praktische Beispiele, die Chain-of-Thought-Ausgaben, strukturierte Datenextraktion und UI-Generierung abdecken. Gut zum Verständnis realer Anwendungsfälle

Worauf du dich konzentrieren solltest: Pydantic-Modelle für deine Daten definieren, Schemas an die API übergeben, den Unterschied zwischen strukturierten Ausgaben und JSON-Modus verstehen und Ablehnungen (Refusals) elegant behandeln

Übungsprojekt: Baue einen Rechnungs- oder Belegparser. Gib ihm Rohtext (z.B. "Rechnung Nr. 123, 45,99 € für 3 Widgets, fällig am 30. März") und lass ihn ein strukturiertes Python-Objekt mit Feldern wie rechnungsnummer, betrag, artikel, faelligkeitsdatum zurückgeben

4. Funktions- / Tool-Aufruf

Tool-Aufrufe sind das, was ein LLM von einem Textgenerator in etwas verwandelt, das Aktionen ausführen kann – das Web durchsuchen, eine Datenbank abfragen, deine API aufrufen, Code ausführen. Es ist eine der wichtigsten Fähigkeiten in diesem gesamten Leitfaden

Wie du es verstehst: Das Modell führt deine Funktionen nicht tatsächlich aus

Es untersucht den Prompt und gibt einen strukturierten Aufruf mit dem Funktionsnamen und den Argumenten zurück, wenn es entscheidet, dass ein Tool verwendet werden sollte

Dein Code führt dann den Aufruf aus und sendet das Ergebnis zurück

Ressourcen:

1. OpenAI Leitfaden zum Funktionsaufruf (offizielle Dokumentation, kostenlos)

Link: https://platform.openai.com/docs/guides/function-calling

Die maßgebliche Referenz. Behandelt das Definieren von Tools, den 5-Schritte-Aufrufablauf, parallele Aufrufe und Best Practices

2. Anthropic Dokumentation zur Tool-Nutzung (kostenlos)

Link: https://docs.anthropic.com/en/docs/build-with-claude/tool-use

Anthropics entsprechender Leitfaden für Claude. Die Konzepte sind dieselben, die Syntax ist etwas anders

3. OpenAI Kochbuch: Wie man Funktionen mit Chat-Modellen aufruft (kostenlos, GitHub)

Link: https://github.com/openai/openai-cookbook/blob/main/examples/How_to_call_functions_with_chat_models.ipynb

Ein vollständig ausführbares Notebook, das den gesamten Tool-Aufrufzyklus mit echten Beispielen durchgeht

Worauf du dich konzentrieren solltest: Funktionen klar im JSON-Schema beschreiben, Tool-Aufrufantworten parsen, die Funktion ausführen und Ergebnisse zurückführen, Fälle behandeln, in denen kein Tool-Aufruf nötig ist, und das Konzept von tool_choice: "auto"

Übungsprojekt: Baue einen einfachen Assistenten mit drei Tools: get_weather(stadt), berechne(ausdruck) und suche_notizen(abfrage) (durchsuche einfach ein fest codiertes Dict). Verkabel sie alle und beobachte, wie das Modell basierend auf deiner Frage entscheidet, welches Tool aufgerufen werden soll

5. Streaming-Antworten

Streaming bedeutet, dass die Ausgabe des Modells während der Generierung angezeigt wird – Wort für Wort – anstatt auf die vollständige Antwort zu warten. Das lässt deine Apps deutlich schneller und lebendiger wirken

Ressourcen:

1. OpenAI Streaming-Dokumentation (offiziell, kostenlos)

Link: https://platform.openai.com/docs/api-reference/streaming

Die Referenz zum Hinzufügen von stream=True zu Anfragen und zum Iterieren über Chunks

2. Anthropic Streaming-Dokumentation (offiziell, kostenlos)

Link: https://docs.anthropic.com/en/api/messages-streaming

Anthropics Streaming-API-Referenz mit Python-Beispielen

3. Wie Streaming-LLM-APIs funktionieren – Simon Willison (kostenlos)

Link: https://til.simonwillison.net/llms/streaming-llm-apis

Eine klare technische Aufschlüsselung, wie Server-Sent Events unter der Haube für OpenAI, Anthropic und Google funktionieren. Nützlich, um zu verstehen, was auf HTTP-Ebene tatsächlich passiert

Worauf du dich konzentrieren solltest: stream=True setzen, über Delta-Chunks iterieren, die vollständige Antwort aus Teilen zusammensetzen und Streaming in einen FastAPI-Endpunkt mit StreamingResponse einbinden

Tipp: Streaming ist fast immer die richtige Wahl für benutzerorientierte Apps. Niemand will 10 Sekunden auf einen Ladespinner starren und darauf warten, dass eine vollständige Antwort auf einmal erscheint

5. Gesprächsverlauf

LLMs sind zustandslos – sie haben kein Gedächtnis zwischen Aufrufen. Der Gesprächsverlauf wird von dir verwaltet, indem du bei jeder Anfrage die gesamte Nachrichtenliste mitschickst. Das zu verstehen, ist grundlegend

Ressourcen:

1. OpenAI Chat Completions Leitfaden, Gespräche verwalten (offiziell, kostenlos)

Link: https://platform.openai.com/docs/guides/conversation-state

Die kanonische Erklärung, wie das Nachrichten-Array funktioniert und wie man Gespräche mit mehreren Turns verwaltet

2. Anthropic Messages API Dokumentation (offiziell, kostenlos)

Link: https://docs.anthropic.com/en/api/messages

Anthropics Äquivalent. Gleiches Konzept, es lohnt sich, beide zu lesen, um zu sehen, wie sie sich unterscheiden

Worauf du dich konzentrieren solltest: Die Struktur des Nachrichten-Arrays, warum du sowohl Benutzer- als auch Assistentennachrichten anhängst, Context-Window-Grenzen und was passiert, wenn du sie überschreitest, und grundlegende Kürzungsstrategien (älteste Nachrichten verwerfen, Zusammenfassung des Verlaufs)

Übungsprojekt: Baue einen einfachen Multi-Turn-Chatbot im Terminal. Jeder Turn hängt die Nachricht an die Nachrichtenliste an. Füge einen /reset-Befehl hinzu, um den Verlauf zu löschen, und gib nach jedem Austausch die aktuelle Token-Anzahl aus

6. Kosten, Latenz und Token-Grundlagen

KI-Apps auszuliefern, ohne Kosten und Token zu verstehen, führt zu bösen Überraschungen bei der Rechnung und langsamen Apps. Das ist langweilig, aber entscheidend

Ressourcen:

1. OpenAI Preisseite (offiziell)

Link: https://openai.com/api/pricing

Wisse, was Input- und Output-Tokens pro Modell kosten. Lesezeichen setzen und jedes Mal überprüfen, wenn du ein Modell auswählst

2. Anthropic Preisseite (offiziell)

Link: https://www.anthropic.com/pricing

Gleiches für Claude-Modelle

3. OpenAI Tokenizer Tool (kostenlos, interaktiv)

Link: https://platform.openai.com/tokenizer

Füge beliebigen Text ein und sieh genau, wie viele Token es sind. Verwende dies ständig während des Lernens

4. Tiktoken (Python-Bibliothek, kostenlos)

Link: https://github.com/openai/tiktoken

OpenAIs Tokenizer-Bibliothek zum Zählen von Token im Code, bevor Anfragen gesendet werden

Worauf du dich konzentrieren solltest: Was ein Token ist (ungefähr 4 Zeichen / 3/4 eines Wortes), wie Input- vs. Output-Tokens unterschiedlich bepreist werden, wie die Context-Window-Größe beeinflusst, was du tun kannst, und der Latenz-Kompromiss zwischen kleineren, schnelleren Modellen und größeren, intelligenteren

Auch: Verwende nicht GPT-4/Opus für alles – günstigere Modelle sind für einfache Aufgaben oft gut genug

7. Fehlerbehandlung

LLM-APIs fallen aus. Rate Limits werden erreicht, Antworten laufen in ein Timeout, das Modell gibt fehlerhaftes JSON zurück. Fehler elegant zu behandeln, ist das, was eine Demo von einer Produktions-App unterscheidet

Ressourcen:

1. OpenAI Fehlercode-Referenz (offiziell, kostenlos)

Link: https://platform.openai.com/docs/guides/error-codes

Jeder Fehlertyp, auf den du treffen wirst, und was du dagegen tun kannst

2. Anthropic Dokumentation zur Fehlerbehandlung (offiziell, kostenlos)

Link: https://docs.anthropic.com/en/api/errors

Gleiches für Claude

3. Tenacity (Python-Bibliothek, kostenlos)

Link: https://tenacity.readthedocs.io/

Eine saubere Bibliothek, um jeder Python-Funktion Wiederholungslogik mit exponentiellem Backoff hinzuzufügen. Ein Dekorator und deine Wiederholungen sind erledigt

Worauf du dich konzentrieren solltest: Rate-Limit-Fehler (429) und exponentieller Backoff, Timeout-Behandlung mit httpx/requests, Modellausgabe vor der Verwendung validieren, Fallback-Strategien (Wiederholung mit einem anderen Modell, gecachte Antwort zurückgeben) und deine App niemals abstürzen lassen, weil das LLM eine unerwartete Ausgabe geliefert hat

8. Bewusstsein für Prompt-Injection

Prompt-Injection ist das Sicherheitsrisiko Nr. 1 bei LLM-Anwendungen

Es tritt auf, wenn nicht vertrauenswürdige Benutzereingaben mit Systemanweisungen kombiniert werden, sodass ein Benutzer das Verhalten des Prompts ändern, überschreiben oder neuen Code einschleusen kann – was dazu führt, dass das System unbeabsichtigte Aktionen ausführt oder manipulierte Ausgaben generiert

Du musst kein Sicherheitsexperte sein, aber du musst wissen, dass es das gibt, bevor du etwas auslieferst

Ressourcen:

1. OWASP Top 10 für LLM-Apps – LLM01: Prompt-Injection (kostenlos)

Monat 1: Prompt Engineering, Tool-Nutzung und API-Grundlagen

Link: https://genai.owasp.org/llmrisk/llm01-prompt-injection/

Die maßgebliche Klassifikation, die direkte Injections (Jailbreaking), indirekte Injections über externe Inhalte wie Dokumente oder Websites sowie reale Angriffsszenarien abdeckt

2. OWASP Prompt Injection Prevention Cheat Sheet (kostenlos)

Link: https://cheatsheetseries.owasp.org/cheatsheets/LLM_Prompt_Injection_Prevention_Cheat_Sheet.html

Praktische Abwehrmuster: Eingabevalidierung, Zugriffskontrolle und Ausgabevalidierung

3. Evidently AI: Was ist Prompt Injection (kostenlos)

Link: https://www.evidentlyai.com/llm-guide/prompt-injection-llm

Eine klare, entwicklerorientierte Erklärung zu Angriffstypen, Risiken und Entwurfsmustern zur Absicherung

Worauf du dich konzentrieren solltest: Der Unterschied zwischen direkter und indirekter Injection, warum System-Prompts nicht wirklich "sicher" sind, das Prinzip der geringsten Privilegien für Tool-Zugriff und warum du niemals ungeprüften LLM-Output automatisch für wichtige Entscheidungen verwenden solltest

Monat 2: Fortgeschrittenes Prompt Engineering, strukturierte Ausgaben, Tool Calling & Streams

Meilenstein Monat 2

Bis Ende dieses Monats solltest du in der Lage sein:

• Prompts zu schreiben, die konsistente, zuverlässige Ergebnisse für eine bestimmte Aufgabe liefern
• Strukturierte JSON-Daten aus jedem Modell mit Pydantic + Instructor zu extrahieren
• Tool Calling einzurichten, damit ein Modell deine Python-Funktionen aufrufen kann
• Antworten in Echtzeit über einen FastAPI-Endpunkt zu streamen
• Mehrrundige Gesprächsverläufe korrekt zu verwalten
• Die Token-Kosten einer Anfrage abzuschätzen, bevor du sie sendest
• API-Fehler, Timeouts und fehlerhafte Ausgaben abzufangen, ohne dass das System abstürzt
• Zu erklären, was Prompt Injection ist, und grundlegende Abwehrmaßnahmen anzuwenden

⏩------------------------------------------------------------------------⏪

Monat 3: RAG richtig lernen

Dein Ziel in diesem Monat: Systeme bauen, die LLMs erlauben, Fragen aus deinen Dokumenten zu beantworten – nicht nur aus ihren Trainingsdaten

Am Ende solltest du Dokumente erfassen, einbetten und speichern, die richtigen Textabschnitte zur Abfragezeit abrufen und Antworten liefern können, die fundiert, genau und nachvollziehbar sind

RAG ist aktuell die gefragteste praktische Fähigkeit im KI-Engineering. Fast jeder reale Enterprise-KI-Anwendungsfall – Chatbots für den Kundenservice, interne Wissensdatenbanken, Dokumenten-Q&A – basiert darauf

Es wirklich tief zu verstehen – und nicht nur ein Tutorial zu kopieren – ist das, was gute Ingenieure von großartigen unterscheidet

1. Embeddings

Bevor du ein RAG-System bauen kannst, musst du verstehen, was Embeddings eigentlich sind – denn sie sind die Grundlage, auf der alles andere aufbaut

Ein Text-Embedding ist ein Text, der in einen hochdimensionalen Vektorraum projiziert wird

Die Position dieses Textes in diesem Raum wird als eine lange Zahlenfolge dargestellt

Entscheidend ist: Semantisch ähnliche Texte landen in diesem Raum nahe beieinander – das ist es, was die Ähnlichkeitssuche überhaupt erst möglich macht

Ressourcen:

1. Stack Overflow Blog: Eine intuitive Einführung in Text-Embeddings (kostenlos)

Link: https://stackoverflow.blog/2023/11/09/an-intuitive-introduction-to-text-embeddings/

Die beste Erklärung für Anfänger. Geschrieben von einem Entwickler, der seit Jahren NLP-Produkte baut, mit dem Fokus, die richtige Intuition aufzubauen – nicht die Mathematik dahinter

2. Google ML Crash Course: Embeddings (kostenlos)

Link: https://developers.google.com/machine-learning/crash-course/embeddings

Erklärt, warum dichte Vektorrepräsentationen Probleme lösen, die One-Hot-Encoding nicht lösen kann – insbesondere die Erfassung semantischer Beziehungen zwischen Elementen

3. HuggingFace: Erste Schritte mit Embeddings (kostenlos)

Link: https://huggingface.co/blog/getting-started-with-embeddings

Praktische Anleitung. Zeigt, wie man Embeddings mit der sentence-transformers-Bibliothek erstellt, hostet und für die semantische Suche über einen echten FAQ-Datensatz nutzt

4. OpenAI Embeddings Guide (offizielle Doku, kostenlos)

Link: https://platform.openai.com/docs/guides/embeddings

Die Referenz für die Verwendung der OpenAI-Modelle text-embedding-3-small und text-embedding-3-large im Code

Worauf du dich konzentrieren solltest: Was ein Vektor konzeptionell ist, warum ähnlicher Text ähnliche Vektoren erzeugt, wie Cosine Similarity funktioniert, der Unterschied zwischen Embedding-Modellen (OpenAI, HuggingFace sentence-transformers) und was die Embedding-Dimension in der Praxis bedeutet

Übung: Nimm 20 Sätze zu verwandten Themen, bette sie mit OpenAI oder sentence-transformers ein und schreibe eine einfache Nächste-Nachbarn-Suche, die die 3 ähnlichsten Sätze zu einer Abfrage zurückgibt. Das ist im Kleinen buchstäblich das Herz von RAG

2. Chunking

Deine Dokumente sind zu groß, um sie als Ganzes einzubetten. Chunking ist der Prozess, sie in kleinere Stücke zu zerlegen, bevor sie eingebettet werden

Wie du deine Dokumente chunkst, wirkt sich direkt darauf aus, ob dein System relevante Informationen finden und genaue Antworten geben kann – selbst ein perfektes Retrieval-System versagt, wenn es über schlecht aufbereitete Daten sucht

Ressourcen:

1. Weaviate: Chunking-Strategien für RAG (kostenlos)

Link: https://weaviate.io/blog/chunking-strategies-for-rag

Die praktischste Anleitung. Deckt Fixed-Size-, rekursives und semantisches Chunking ab, mit klaren Hinweisen, wann man welches verwendet

2. Unstructured: Chunking für RAG – Best Practices (kostenlos)

Link: https://unstructured.io/blog/chunking-for-rag-best-practices

Ein technischer Deep-Dive zu Chunk-Größen, Überlappung und wie der Kontextfenster des Embedding-Modells harte Grenzen setzt

Ein guter Ausgangspunkt für Experimente ist eine Chunk-Größe von etwa 250 Tokens (ungefähr 1.000 Zeichen), kombiniert mit einer 10-20%igen Überlappung zwischen aufeinanderfolgenden Chunks, um Kontextverluste an den Grenzen zu vermeiden

3. LangChain Text Splitters Docs (offiziell, kostenlos)

Link: https://python.langchain.com/docs/concepts/text_splitters/

Die praktische Referenz für die Verwendung von RecursiveCharacterTextSplitter, MarkdownTextSplitter und semantischen Splintern im Code

Worauf du dich konzentrieren solltest: Fixed-Size-Chunking mit Überlappung als Ausgangsbasis, rekursives Chunking für strukturierte Dokumente, semantisches Chunking für bessere Grenzerkennung und der grundlegende Zielkonflikt: Zu große Chunks verlieren an Retrieval-Genauigkeit; zu kleine Chunks verlieren Kontext

Anfängertipp: Beginne mit RecursiveCharacterTextSplitter von LangChain mit chunk_size=500 und chunk_overlap=50. Das ist der sinnvollste Standard für die meisten Dokumente und gibt dir eine funktionierende Basis, von der aus du verbessern kannst

3. Vektordatenbanken

Sobald du Embeddings hast, brauchst du einen Ort, um sie effizient zu speichern und zu durchsuchen. Dafür sind Vektordatenbanken da

Die richtige Wahl hängt von deiner Situation ab: Verwende Chroma für schnelles lokales Prototyping, Pinecone für verwaltete Skalierung aus einer Hand, Weaviate für Open-Source-Flexibilität mit starker Hybridsuche, Qdrant für komplexe Filter und kosteneffizientes Self-Hosting und pgvector, wenn du bereits PostgreSQL verwendest und kein weiteres System hinzufügen möchtest

Ressourcen:

1. Chroma Offizielle Doku (kostenlos)

Link: https://docs.trychroma.com/

Chroma ist perfekt für einzelne Entwickler und kleine Teams, die Entwicklungsgeschwindigkeit und Einfachheit priorisieren – es läuft im Arbeitsspeicher oder lokal ohne zu verwaltende Infrastruktur

2. Pinecone Learning Center (kostenlos)

Link: https://www.pinecone.io/learn/

Hervorragende kostenlose Tutorials, die Konzepte der Vektorsuche, Hybridsuche und RAG-Pipelines abdecken. Gute anbieterunabhängige Materialien, auch wenn du Pinecone nicht verwendest

3. Qdrant Dokumentation (kostenlos)

Link: https://qdrant.tech/documentation/

Beste Open-Source-Option für die Produktion mit erweiterter Filterung. Sehr schnell, flexibel und kostenlos selbst hostbar

4. pgvector (Open Source, kostenlos)

Link: https://github.com/pgvector/pgvector

Wenn du bereits etwas baust, das PostgreSQL verwendet, fügt pgvector die Vektorsuche direkt in deine bestehende Datenbank ein – ohne neue Infrastruktur

Worauf du dich konzentrieren solltest: Eine Collection erstellen, Embeddings mit Metadaten einfügen, nach Ähnlichkeit mit top_k abfragen und zur Abfragezeit nach Metadaten filtern

Du musst die Indizierungsalgorithmen (HNSW, IVF) nicht verstehen – nur wissen, wie man sie verwendet

Übungsprojekt: Indiziere 50-100 Seiten aus einer beliebigen öffentlichen Dokumentation (z. B. die Python-Dokumentation oder einen Wikipedia-Artikel-Dump) in Chroma mit Metadaten (Quell-URL, Abschnittstitel). Schreibe eine Abfragefunktion, die die 5 relevantesten Chunks für jede Frage abruft

4. Metadaten-Filterung

Die reine Ähnlichkeitssuche allein reicht für echte Anwendungen nicht aus. Mit Metadaten-Filterung kannst du die Suche auf eine relevante Teilmenge einschränken – nach Datum, Quelle, Dokumenttyp, Benutzer, Kategorie oder jedem anderen Attribut, das du zusammen mit jedem Chunk speicherst

Ressourcen:

1. Pinecone: Metadaten-Filterung Leitfaden (kostenlos)

Link: https://docs.pinecone.io/guides/data/filter-with-metadata

Klare Erklärung mit Code-Beispielen zum Filtern von Vektoren nach Metadatenfeldern vor oder während der Ähnlichkeitssuche

2. LlamaIndex: Metadaten-Filter Leitfaden (offizielle Doku, kostenlos)

Link: https://docs.llamaindex.ai/en/stable/module_guides/querying/node_postprocessors/node_postprocessors/

Erklärt, wie man Filter zur Abfragezeit in LlamaIndex-Pipelines anwendet

Worauf du dich konzentrieren solltest: Jeden Chunk beim Einfügen mit relevanten Metadaten versehen (Quelldateiname, Seitenzahl, Abschnitt, Datum, Kategorie) und diese Felder verwenden, um die Ergebnisse zur Abfragezeit zu filtern. Das ist der Unterschied zwischen einer Spielzeug-Demo und einem Produktionssystem, in dem Benutzer fragen können: "Zeige mir nur Ergebnisse aus den Berichten Q4 2025-Q1 2026"

5. Reranking

Reranking ist eine Technik, die die Suchqualität jedes Stichwort- oder Vektorsuchsystems semantisch verbessert

Nachdem die erste Retrieval-Stufe einen Kandidatensatz zurückgegeben hat, bewertet ein Reranker diese Ergebnisse basierend auf der tatsächlichen kontextuellen Relevanz zur Abfrage neu – nicht nur basierend auf der Vektor-Ähnlichkeit

Das zweistufige Muster ist: Einbetten und Suchen (schnell, approximativ) → Reranking der top-k (langsamer, genauer). Das Ergebnis ist eine dramatisch bessere Retrieval-Qualität bei nur geringen Latenzkosten

Ressourcen:

1. Cohere Reranking Docs (offiziell, kostenlos)

Link: https://docs.cohere.com/docs/reranking-with-cohere

Der beste Einstieg. Deckt den gesamten Reranking-Workflow ab, einschließlich halbstrukturierter Daten wie E-Mails und JSON-Dokumente. Erfordert nur eine einzige Codezeile, um es zu einer bestehenden Retrieval-Pipeline hinzuzufügen

2. LangChain: Cohere Reranker Integration (offizielle Doku, kostenlos)

Link: https://python.langchain.com/docs/integrations/retrievers/cohere-reranker/

Erklärt, wie man Cohere-Reranking mit ContextualCompressionRetriever in einen LangChain-Retriever einbindet

Worauf du dich konzentrieren solltest: Das zweistufige Retrieve-then-Rerank-Muster, der Unterschied zwischen einem Bi-Encoder (verwendet für die erste Embedding-Suche) und einem Cross-Encoder (verwendet für das Reranking) sowie der praktische Zielkonflikt zwischen Latenz und Qualität beim Reranking von top-20 vs. top-5 Ergebnissen

6. Retrieval-Qualitätsprobleme

Die meisten RAG-Fehler sind keine Modellfehler, sondern Retrieval-Fehler. Die Arten zu verstehen, wie Retrieval schiefgehen kann, ist entscheidend für das Debuggen echter Systeme

Häufige Probleme, die du lernen solltest:

• Semantische Drift: Das Abfrage-Embedding passt nicht zum relevanten Chunk-Embedding, obwohl die Information vorhanden ist. Lösung: Versuche Query Rewriting oder HyDE (Hypothetical Document Embeddings)
• Chunk-Grenzprobleme: Die relevante Information ist auf zwei Chunks verteilt. Lösung: Erhöhe die Überlappung oder verwende semantisches Chunking
• Fehlender Metadaten-Kontext: Chunks sind semantisch ähnlich zur Abfrage, gehören aber zum falschen Dokument, Datum oder Benutzer. Lösung: Verwende Metadaten-Filterung
• top_k zu klein: Der richtige Chunk existiert, ist aber nicht unter den top 5 abgerufenen Ergebnissen. Lösung: Erhöhe top_k beim Retrieval und reduziere nach dem Reranking

Ressourcen:

1. LangChain: Query-Transformationen (kostenlos)

Link: https://python.langchain.com/docs/how_to/#query-analysis

Behandelt Query Rewriting, Step-Back-Prompting und HyDE

2. Pinecone: Verbesserung der Retrieval-Qualität (kostenlos)

Link: https://www.pinecone.io/learn/retrieval-augmented-generation/#retrieval-quality

Praktische Schritt-für-Schritt-Anleitung zu häufigen Fehlermustern mit Lösungen

7. Halluzinationsreduzierung

RAG reduziert Halluzinationen im Vergleich zu einem einfachen LLM dramatisch, beseitigt sie aber nicht vollständig

Indem das Modell zur Laufzeit mit abgerufenen Fakten versorgt wird, verankert RAG seine Antworten in echten Quellen, anstatt sich nur auf Trainingsdaten zu verlassen, und die Ausgabe des Modells kann sogar diese Quellen zitieren, was Transparenz und Vertrauen erhöht

Aber Retrieval-Fehler, schlechte Chunks und widersprüchliche Informationen können immer noch dazu führen, dass das Modell Dinge erfindet

Ressourcen:

1. Zep: Reduzierung von LLM-Halluzinationen – Ein Entwicklerleitfaden (kostenlos)

Link: https://www.getzep.com/ai-agents/reducing-llm-hallucinations/

Praktischer, entwicklerorientierter Leitfaden, der Prompt-Grounding-Strategien, Chain-of-Thought für faktische Aufgaben und Ausgabeüberprüfungsmuster abdeckt

2. Voiceflow: 5 Wege zur Reduzierung von LLM-Halluzinationen (kostenlos)

Link: https://www.voiceflow.com/blog/prevent-llm-hallucinations

Guter Überblick über die kombinierte Strategie: RAG + Chain-of-Thought + Guardrails übertreffen zusammen jeden einzelnen Ansatz

Worauf du dich konzentrieren solltest: Das Modell per Prompt anweisen, nur aus dem bereitgestellten Kontext zu antworten (und "Ich weiß es nicht" zu sagen, wenn die Antwort nicht da ist), eine Konfidenzschwelle hinzufügen, bevor Antworten angezeigt werden, und immer die Retrieval-Qualität überprüfen, bevor du dem LLM die Schuld gibst

8. Quellenangaben und Grounding

Ein fundiertes RAG-System antwortet nicht nur – es sagt dir, woher die Antwort kommt. Das ist entscheidend für das Vertrauen der Benutzer und für das Debugging

Ressourcen:

1. Anthropic: Claude Quellen geben (Doku, kostenlos)

Link: https://docs.anthropic.com/en/docs/build-with-claude/citations

Erklärt, wie man Claude per Prompt dazu bringt, zitierte Antworten mit Quellenverweisen zu erstellen

2. LangChain: RAG mit Quellen (kostenlos)

Link: https://python.langchain.com/docs/how_to/qa_sources/

Erklärt, wie man Quelldokumente zusammen mit Antworten in einer LangChain-RAG-Pipeline zurückgibt

Worauf du dich konzentrieren solltest: Chunk-Metadaten (Quelldateiname, Seitenzahl, URL) in deinen Prompt-Kontext einfügen, das Modell anweisen, Quellen in seiner Antwort zu referenzieren, und diese Quellen in deiner UI oder API-Antwort anzeigen

9. Dein RAG-Framework: LangChain oder LlamaIndex

Du musst keine RAG-Pipeline von Grund auf neu bauen. Zwei Frameworks dominieren den Bereich und sind es wert, gekannt zu werden:

LlamaIndex ist optimiert, um Suche und Indizierung an erste Stelle zu setzen – es abstrahiert Erfassung, Chunking, Embedding und Abfrage in wenige Codezeilen, sodass du an einem Nachmittag einen funktionierenden Prototypen bauen kannst

LangChain glänzt, wenn deine Anwendung eher wie eine Orchestrierungs-Engine aussieht – es eignet sich hervorragend für Multi-Agent-Workflows, Tool Calling und bedingte Ketten, die mehrere LLMs oder externe APIs abfragen, bevor sie eine Antwort generieren

Für Monat 3 starte mit LlamaIndex für RAG. Wechsle zu LangChain, wenn du Monat 4 mit den Agenten erreichst

Ressourcen:

1. LlamaIndex: Einführung in RAG (offizielle Doku, kostenlos)

Link: https://developers.llamaindex.ai/python/framework/understanding/rag/

Behandelt die fünf Schlüsselphasen von RAG: Laden, Indizieren, Speichern, Abfragen und Evaluieren – und wie LlamaIndex jede einzelne handhabt

2. LlamaIndex Starter Tutorial (offizielle Doku, kostenlos)

Link: https://developers.llamaindex.ai/python/framework/getting_started/starter_example/

Der offizielle Schnellstart. Baue ein funktionierendes RAG-System in unter 30 Zeilen

3. LangChain: Einen RAG-Agenten bauen (offizielle Doku, kostenlos)

Link: https://docs.langchain.com/oss/python/langchain/rag

Zeigt, wie man eine Q&A-App über unstrukturierten Text mit einem RAG-Agenten baut, von einer 40-zeiligen Minimalversion bis zu einer vollständigen Retrieval-Pipeline mit Reranking

Übungsprojekt: Baue eine "Chatte mit deinen Dokumenten"-App. Erfasse 10–20 PDF- oder Textdateien (deine eigenen Notizen, ein Lehrbuchkapitel, Produktdokumentation – alles). Baue einen FastAPI-Endpunkt, der eine Frage annimmt, die 5 relevantesten Chunks mit Reranking abruft und eine zitierte Antwort von Claude oder OpenAI zurückgibt. Das ist ein echtes Portfolio-Stück

Meilenstein Monat 3

Bis Ende dieses Monats solltest du in der Lage sein:

• Zu erklären, was ein Embedding ist und warum ähnlicher Text ähnliche Vektoren erzeugt
• Jedes Dokument intelligent mit geeigneten Strategien zu chunken
• Embeddings in einer Vektordatenbank mit Metadaten-Filterung zu speichern und abzufragen
• Einen Reranking-Schritt hinzuzufügen, um die Retrieval-Qualität zu verbessern
• Häufige Retrieval-Fehler systematisch zu debuggen
• Eine vollständige End-to-End-RAG-Pipeline mit LlamaIndex oder LangChain zu bauen, die Dokumente erfasst, relevante Chunks abruft und fundierte, zitierte Antworten zurückgibt

⏩------------------------------------------------------------------------⏪

Monat 4: Agenten, Tools, Workflows und Evals

Dein Ziel in diesem Monat: KI-Systeme bauen, die autonom Sequenzen von Aktionen ausführen können, mehrstufige Workflows miteinander verbinden und kritisch bewerten, ob sie funktionieren

Am Ende solltest du in der Lage sein, einen echten Agenten von Grund auf zu bauen, zu verstehen, wann Agenten die falsche Wahl sind, und die Leistung von allem, was du baust, zu messen

Hier wird KI-Engineering richtig komplex. Die Fähigkeiten aus Monat 4 sind das, was Junior-KI-Ingenieure von Leuten unterscheidet, die eine gesamte KI-Funktion von Anfang bis Ende eigenverantwortlich umsetzen können

1. Agenten-Schleifen

Ein Agent ist keine Magie – er ist ein überraschend einfaches Muster

Stelle dir Agenten als zielorientierte Systeme vor, die ständig den Kreislauf aus Beobachten, Nachdenken und Handeln durchlaufen

Diese Schleife ermöglicht es ihnen, Aufgaben zu bewältigen, die über einfache Fragen und Antworten hinausgehen – hin zu echter Automatisierung, Werkzeugnutzung und spontaner Anpassung

Das "Denken" passiert im Prompt, die "Verzweigung" erfolgt, wenn der Agent zwischen verfügbaren Werkzeugen wählt, und das "Handeln" findet statt, wenn wir externe Funktionen aufrufen. Alles andere ist nur Infrastruktur

Sobald du das verinnerlicht hast, werden selbst die komplexesten Agent-Frameworks lesbar

Ressourcen:

1. Anthropic: Effektive Agenten bauen (offiziell, kostenlos)

Link: https://www.anthropic.com/research/building-effective-agents

Der mit Abstand beste Text über Agenten in der Produktion. Lies das, bevor du eine einzige Zeile Agenten-Code schreibst

2. OpenAI: Ein praktischer Leitfaden zum Bauen von Agenten (offizielles PDF, kostenlos)

Link: https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf

OpenAIs ergänzender Leitfaden, der Agentenmuster, Leitplanken und Sicherheitsmuster in der Produktion abdeckt

3. freeCodeCamp: Das Open-Source-LLM-Agenten-Handbuch (kostenlos)

Link: https://www.freecodecamp.org/news/the-open-source-llm-agent-handbook/

Ein umfassender praktischer Leitfaden, der die Agenten-Schleife, LangGraph, CrewAI, Planung, Gedächtnis und Werkzeugnutzung abdeckt. Gut, um schnell praktische Erfahrung zu sammeln

4. LangChain Academy: Einführung in LangGraph (kostenloser Kurs)

Link: https://academy.langchain.com/courses/intro-to-langgraph

Der offizielle kostenlose Kurs für LangGraph, das am weitesten verbreitete Agenten-Orchestrierungs-Framework. Deckt Zustand, Gedächtnis, Human-in-the-Loop und mehr ab

Worauf du dich konzentrieren solltest: Der Kreislauf Wahrnehmen → Planen → Handeln → Beobachten, wie die Agentenschleife terminiert, was passiert, wenn ein Tool-Aufruf innerhalb einer Schleife fehlschlägt, und warum Agenten im Grunde nur while-Schleifen sind, bei denen ein LLM die Verzweigungsentscheidungen trifft

Übung: Baue einen Agenten von Grund auf ohne Framework – nur mit der OpenAI- oder Anthropic-API direkt. Gib ihm 3 Tools, ein Ziel und eine Schleife. Das ist das Wertvollste, was du tun kannst, um wirklich zu verstehen, was Frameworks abstrahieren

2. Tool-Auswahl

Gute Tools zu schreiben ist die halbe Arbeit. Die Beschreibungen für deine Tools und ihre Parameter sind das Benutzerhandbuch für das LLM. Wenn das Handbuch vage ist, wird das LLM das Tool falsch verwenden. Sei schmerzhaft, unerbittlich explizit

Ein schlecht beschriebenes Tool wird falsch aufgerufen, zur falschen Zeit aufgerufen oder ganz ignoriert. Ein gut beschriebenes Tool verhält sich vorhersagbar und wird über eine breite Palette von Eingaben hinweg korrekt ausgewählt

Ressourcen:

1. OpenAI: Best Practices für Function Calling (offizielle Doku, kostenlos)

Link: https://platform.openai.com/docs/guides/function-calling/best-practices

Der maßgebliche Leitfaden zum Schreiben von Tool-Beschreibungen, die zuverlässig funktionieren, mit Namenskonventionen und Parametern, Dokumentationsmustern

2. Anthropic: Best Practices für die Tool-Nutzung (offizielle Doku, kostenlos)

Link: https://docs.anthropic.com/en/docs/build-with-claude/tool-use/implement-tool-use#best-practices-for-tool-definitions

Anthropics Gegenstück. Achte besonders auf die Hinweise dazu, wann das Modell wählen darf vs. ein bestimmtes Tool erzwungen werden sollte

Worauf du dich konzentrieren solltest: Tool-Namen schreiben, die selbsterklärende Verben sind, Beschreibungen schreiben, die erklären, wann das Tool aufgerufen werden soll (nicht nur, was es tut), Parameter minimal und gut typisiert halten und Tools mit dem LLM als Aufrufer entwerfen

Anfängertipp: Teste jede Tool-Beschreibung, indem du dich fragst: "Wenn ich keine Dokumentation hätte und nur dieses JSON-Schema, würde ich genau wissen, wann und wie ich das aufrufen soll?" Wenn nicht, muss es verbessert werden

3. Zustandsverwaltung

In LangGraph ist der Zustand ein gemeinsames Speicherobjekt, das durch den Graphen fließt. Es speichert alle relevanten Informationen – Nachrichten, Variablen, Zwischenergebnisse und Entscheidungsverlauf – und wird während der gesamten Ausführung automatisch verwaltet

Das Verständnis des Zustands ist der Schlüssel zum Bauen von Agenten, die mehrstufige Aufgaben bewältigen, sich von Fehlern erholen und sauber zwischen Komponenten übergeben können

Ressourcen:

1. LangGraph Offizielle Doku: Zustandsverwaltung (kostenlos)

Link: https://langchain-ai.github.io/langgraph/concepts/low_level/#state

Die definitive Referenz. Behandelt Zustandsschemata, Reducer und wie Zustände durch Nodes und Edges fließen.

2. DataCamp: LangGraph-Agenten-Tutorial (kostenlos)

Link: https://www.datacamp.com/tutorial/langgraph-agents

Behandelt die Grundlagen von Zustand, Nodes und Edges mit praktischem Code, bis hin zu zustandsbehafteten Agenten mit persistentem Speicher über Sitzungen hinweg.

3. Real Python: LangGraph in Python (kostenlos)

Link: https://realpython.com/langgraph-python/

Ein gründliches Tutorial, das einen vollständigen zustandsbehafteten LangGraph-Agenten erstellt, mit detaillierten Erklärungen des Zustandsgraphen und bedingten Edges.

Worauf du dich konzentrieren solltest: Definieren von Zustandsschemata mit TypedDict, wie Reducer funktionieren, um parallele Updates zusammenzuführen, der Unterschied zwischen In-Memory-Zustand und persistiertem Checkpointing, und wie Human-in-the-Loop-Pausen funktionieren, indem der Zustand während der Ausführung inspiziert und geändert wird.

4. Wiederholungen und Fehlerbehandlung bei Agenten

Agenten scheitern anders als gewöhnliche LLM-Aufrufe. Ein schlechter Tool-Aufruf in der Mitte einer Schleife kann den Zustand beschädigen, Endlosschleifen verursachen oder stillschweigend falsche Antworten produzieren. Du brauchst explizite Strategien für all diese Fälle.

Ressourcen:

1. LangGraph: Fehlerbehandlung und Wiederholungen (offizielle Dokumentation, kostenlos)

Link: https://langchain-ai.github.io/langgraph/how-tos/autofill-tool-errors/

Erklärt, wie man in LangGraph auf Tool-Ebene automatische Fehlerbehandlung und Wiederholungslogik hinzufügt.

2. OpenAI Practical Agents Guide: Guardrails-Abschnitt (kostenlos)

Link: https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf

Behandelt Guardrails als mehrschichtige Verteidigung, die LLM-basierte Prüfungen, regelbasierte Filter wie Regex und Moderations-APIs kombiniert, um sowohl Eingaben als auch Ausgaben in jeder Phase der Agentenschleife zu überprüfen.

Worauf du dich konzentrieren solltest: Maximale Iterationsgrenzen, um Endlosschleifen zu verhindern, tool-spezifische Wiederholungen mit exponentiellem Backoff, Abfangen und Protokollieren von Ausnahmen auf der Tool-Ausführungsebene ohne Absturz des Agenten, und wann man einen Fehler dem Benutzer anzeigt vs. stillschweigend wiederholt.

5. Wann man KEINE Agenten einsetzen sollte

Dies ist eine der wichtigsten und am meisten übersehenen Fähigkeiten im KI-Engineering. Agenten sind aufregend, aber auch langsam, teuer, unberechenbar und schwer zu debuggen. Zu wissen, wann man zu etwas Einfacherem greifen sollte, ist ein Zeichen von gutem Urteilsvermögen.

Anthropic empfiehlt, die einfachste mögliche Lösung zu finden und die Komplexität nur dann zu erhöhen, wenn es nötig ist – das kann bedeuten, überhaupt keine agentischen Systeme zu bauen.

Agentische Systeme tauschen Latenz und Kosten gegen bessere Aufgabenleistung ein, und du solltest sorgfältig abwägen, wann dieser Trade-off sinnvoll ist.

Das Entscheidungsframework ist:

• Verwende einen einzelnen LLM-Aufruf, wenn die Aufgabe mit dem richtigen Kontext in einem Prompt gelöst werden kann.
• Verwende einen Workflow, wenn die Schritte fest und vorhersehbar sind.
• Verwende einen Agenten nur, wenn die Anzahl der Schritte wirklich unvorhersehbar ist und dynamische Entscheidungen erfordert.

Ressourcen:

1. Anthropic: Effektive Agenten bauen, wann man Agenten einsetzt (offiziell, kostenlos)

Link: https://www.anthropic.com/research/building-effective-agents

Die maßgeblichste Antwort auf diese Frage, direkt vom Team, das die Modelle baut.

2. Simon Willison: Entwerfen von agentischen Schleifen (kostenlos)

Link: https://simonwillison.net/2025/Sep/30/designing-agentic-loops/

Die praktische Sicht eines erfahrenen Entwicklers darauf, wann Agentenkomplexität gerechtfertigt ist und wie man über das Design agentischer Schleifen nachdenkt.

Was du auswendig lernen solltest: Eine Kette von 3 festen LLM-Aufrufen wird immer schneller, günstiger und besser debuggbar sein als ein Agent, der 3 Aufrufe machen könnte. Hebe dir Agenten für wirklich offene Aufgaben auf.

6. Mehrschritt-Workflows

Zwischen „einem Prompt" und „vollem Agenten" gibt es ein riesiges produktives Mittelfeld: Workflows. Workflows sind ideal, wenn die Aufgabe sauber in feste Unteraufgaben zerlegt werden kann – sie tauschen Latenz gegen höhere Genauigkeit, indem sie jeden einzelnen LLM-Aufruf zu einer einfacheren, fokussierteren Aufgabe machen.

Häufige Muster sind Prompt-Chaining (Ausgabe eines Aufrufs ist Eingabe für den nächsten), Routing (Eingabe klassifizieren und an spezialisierte Handler senden), Parallelisierung (mehrere Aufrufe gleichzeitig ausführen und Ergebnisse zusammenführen) und Orchestrator-Unteragent (ein LLM plant, andere führen aus).

Ressourcen:

1. Anthropic: Workflow-Muster (offiziell, kostenlos)

Link: https://www.anthropic.com/research/building-effective-agents#workflow-patterns

Behandelt alle Hauptmuster mit Diagrammen und Codebeispielen. Die Abschnitte zu Parallelisierung und Orchestrierung sind besonders nützlich.

2. LangGraph: Multi-Agenten-Netzwerke (offizielle Dokumentation, kostenlos)

Link: https://langchain-ai.github.io/langgraph/concepts/multi_agent/

Erklärt, wie man mehrere Agenten als Netzwerk zusammenschaltet, mit Supervisor- und Übergabemustern.

Übungsprojekt: Erstelle eine 3-stufige Content-Pipeline:

Schritt 1 – ein LLM extrahiert Schlüsselfakten aus einem Artikel.

Schritt 2 – ein weiterer LLM-Aufruf verwendet diese Fakten, um parallel einen Tweet, einen LinkedIn-Post und eine Zusammenfassung zu generieren.

Schritt 3 – ein abschließender LLM-Aufruf bewertet alle drei nach Qualität und wählt das beste aus.

Kein Agent nötig, reiner Workflow.

7. Evaluierungs-Harness

Evals sind die Art und Weise, wie du weißt, ob dein KI-System tatsächlich funktioniert – nicht nur an den Beispielen, die du von Hand getestet hast, sondern systematisch über Hunderte von Eingaben hinweg.

KI-Agenten sind mächtig, aber komplex in der Bereitstellung, da ihr probabilistisches, mehrschrittiges Verhalten viele Fehlerquellen einführt.

Verschiedene Teile eines Agenten – die LLMs, Tools, Retriever und Workflows – benötigen jeweils ihren eigenen Evaluierungsansatz.

Ressourcen:

1. DeepEval (Open Source, kostenlos)

Link: https://deepeval.com/docs/getting-started

Ein Open-Source-LLM-Evaluierungsframework, inspiriert von pytest. Schreibe Testfälle mit Eingaben und erwarteten Ausgaben, führe sie mit über 50 integrierten Metriken aus, darunter Halluzination, Antwortrelevanz und faktische Konsistenz, und fange Regressionen zwischen Versionen ab.

2. [Promptfoo (Open Source, kostenlos)](https://github.com/promptfoo/promptfoo)

Link: https://github.com/promptfoo/promptfoo

Ein CLI und eine Bibliothek zum Testen und Evaluieren von LLM-Apps mit automatisierten Testsuites. Unterstützt den Seitenvergleich mehrerer Prompts über mehrere Modelle, CI/CD-Integration und Red Teaming für Sicherheitslücken.

3. LangSmith (kostenlose Stufe)

Link: https://smith.langchain.com/

Tracing, Debugging und Evaluation für LangChain- und LangGraph-Apps. Die kostenlose Stufe ist großzügig und die Tracing-Oberfläche macht das Debuggen von Agentenschleifen erheblich einfacher.

4. Ragas (Open Source, kostenlos)

Link: https://docs.ragas.io/

Spezialisiertes Evaluierungsframework für RAG-Pipelines. Misst Faktentreue, Antwortrelevanz, Kontextpräzision und Kontextabdeckung. Essentiell, wenn du RAG-Systeme aus Monat 3 evaluierst.

Worauf du dich konzentrieren solltest: Erstellen eines goldenen Testsets von 20–50 repräsentativen Eingaben mit erwarteten Ausgaben oder Bewertungskriterien, Schreiben von Evaluierungsfunktionen, die Ausgaben deterministisch bewerten (String-Vergleich, JSON-Schema-Validierung) oder mit LLM-als-Richter, und automatisches Ausführen von Evals, wenn du einen Prompt änderst oder ein Modell austauschst.

Wichtige Denkweise: Evals sind kein optionaler Feinschliff. Jede Prompt-Änderung, jeder Modellwechsel oder jede Retriever-Anpassung, die du ohne Evals vornimmst, ist ein Glücksspiel. Die Entwickler, die zuverlässige KI-Produkte ausliefern, führen ständig Evals durch.

8. Metriken für den Aufgabenerfolg

Über automatisierte Evals hinaus brauchst du Metriken, die dir sagen, ob dein Agent sein eigentliches Ziel erreicht.

Ressourcen:

1. Hamel Husain: Dein KI-Produkt braucht Evals (kostenlos)

Link: https://hamel.dev/blog/posts/evals/

Einer der praktischsten Texte, die je über den Bau von Evaluierungs-Pipelines für echte Produktions-KI-Systeme geschrieben wurden, von jemandem, der es in großem Maßstab getan hat.

2. OpenAI Evals Framework (Open Source, kostenlos)

Link: https://github.com/openai/evals

OpenAIs eigenes Evaluierungsframework, mit einer großen Bibliothek von Community-beigesteuerten Evaluierungsmustern, die du anpassen kannst.

Worauf du dich konzentrieren solltest: Der Unterschied zwischen Prozessmetriken (Hat der Agent das richtige Tool aufgerufen?) und Ergebnismetriken (War die Aufgabe erfolgreich?), das Definieren klarer Erfolgskriterien bevor du etwas baust, und die Verwendung von LLM-als-Richter für die Evaluierung von Ausgaben, die sich exaktem Matching widersetzen (wie ausführliche Antworten oder mehrschrittige Argumentationsketten).

Übungsprojekt: Nimm deine RAG-Pipeline aus Monat 3 und baue einen ordentlichen Evaluierungs-Harness darum herum. Erstelle 30 Frage-Antwort-Paare aus deinen Dokumenten, führe sie durch deine Pipeline und bewerte jede Antwort auf Relevanz, Faktentreue und Vollständigkeit mit DeepEval. Ändere dann eine Sache (Chunk-Größe, Modell, Top-K) und führe sie erneut aus, um zu sehen, ob es besser geworden ist.

Meilenstein Monat 4

Am Ende dieses Monats solltest du in der Lage sein:

• Erklären, was eine Agentenschleife ist, und eine von Grund auf ohne Framework implementieren.
• Tool-Beschreibungen schreiben, die korrekt und zuverlässig ausgewählt werden.
• Agentenzustand mit LangGraph oder Äquivalent richtig verwalten.
• Fehler innerhalb von Agentenschleifen behandeln, ohne dass sie abstürzen.
• Sicher entscheiden, ob eine Aufgabe einen Agenten, einen Workflow oder einen einzelnen Prompt benötigt.
• Mehrschritt-Workflows bauen, die LLM-Aufrufe verketten, routen und parallelisieren.
• Automatisierte Evals schreiben, die Regressionen abfangen, wenn du Prompts oder Modelle änderst.
• Metriken für den Aufgabenerfolg für jedes von dir gebaute KI-System definieren und messen.

⏩------------------------------------------------------------------------⏪

Monat 5: Deployment, Produktdenken und Zuverlässigkeit

Dein Ziel diesen Monat: Nimm alles, was du gebaut hast, und mache es produktionsreif.

Am Ende solltest du in der Lage sein, eine KI-App bereitzustellen, die echte Benutzer, echten Traffic und echte Fehler verkraftet, ohne um 2 Uhr morgens auseinanderzufallen.

Hier bleiben die meisten KI-Entwickler stecken. Sie können eine tolle Demo bauen, aber kein Produkt ausliefern, das den Kontakt mit der realen Welt überlebt.

Die Fähigkeiten hier sind das, wofür Unternehmen tatsächlich bezahlen: Zuverlässigkeit, Sicherheit, Kostenkontrolle und die Fähigkeit, Dinge am Laufen zu halten, wenn unweigerlich etwas kaputtgeht.

1. FastAPI-Produktionsmuster

Du weißt bereits, wie man eine FastAPI-App aus Monat 1 baut. Jetzt musst du sie so machen, dass sie Produktionstraffic überlebt.

Der Unterschied zwischen Dev und Prod ist brutal. Ein einzelner Uvicorn-Prozess mit --reload ist zum Bauen in Ordnung. In der Produktion wird er zum Engpass, sobald echter Traffic ankommt.

Was du wirklich brauchst: Multi-Worker-ASGI-Konfiguration, ordentliche Middleware für Fehlerbehandlung, Health-Check-Endpunkte und CORS-Richtlinien.

Ressourcen:

1. FastAPI-Deployment-Dokumentation (offiziell, kostenlos)

Link: https://fastapi.tiangolo.com/deployment/

Der offizielle Leitfaden, der Uvicorn-Worker, Gunicorn und Docker-Deployment abdeckt. Fang hier an, bevor du etwas anderes tust.

2. FastAPI-Produktions-Deployment-Leitfaden (CYS Docs, kostenlos)

Link: https://craftyourstartup.com/cys-docs/fastapi-production-deployment/

Umfassende Produktionsmuster: Gunicorn-Konfiguration, Nginx-Reverse-Proxy, Health Checks, Ratenbegrenzung. Enthält echte Konfigurationsdateien, die du anpassen kannst.

3. FastAPI Best Practices für die Produktion (FastLaunchAPI, kostenlos)

Link: https://fastlaunchapi.dev/blog/fastapi-best-practices-production-2026

Behandelt asynchrone Datenbank-Pooling, Redis-Caching, JWT-Auth und Hintergrundaufgaben. Produktionserprobte Muster aus einer echten Vorlage, die von über 100 Entwicklern verwendet wird.

Worauf du dich konzentrieren solltest: Ausführen von Gunicorn mit Uvicorn-Workern (nicht nacktem Uvicorn), Einrichten von Health-Check-Endpunkten, Hinzufügen von CORS-Middleware, Implementieren ordnungsgemäßer asynchroner Datenbanksitzungen und Verwenden von Hintergrundaufgaben für alles, was die Antwort nicht blockieren muss.

2. Docker

Docker ist, wie du aufhörst zu sagen „bei mir läuft's" und anfängst, konsistente Deployments auszuliefern.

Wenn du KI-Apps baust, löst Docker Abhängigkeitskonflikte, sorgt für konsistente Umgebungen und macht Skalierung unkompliziert.

Du musst kein Docker-Experte werden. Du musst in der Lage sein, deine FastAPI + LLM-App zu containerisieren und überall bereitzustellen.

Ressourcen:

1. Docker Offizieller Erste-Schritte-Leitfaden (kostenlos)

Link: https://docs.docker.com/get-started/

Der kanonische Ausgangspunkt. Behandelt Images, Container, Dockerfiles und Docker Compose.

2. freeCodeCamp: So baust und deployst du ein Multi-Agenten-KI-System mit Python und Docker (kostenlos)

Link: https://www.freecodecamp.org/news/build-and-deploy-multi-agent-ai-with-python-and-docker/

Praktisches End-to-End-Tutorial, das eine echte Multi-Agenten-Pipeline mit Docker Compose erstellt. Behandelt Aufgabentrennung, Cron-Job-Planung und Sicherheitsaspekte.

3. DataCamp: LLM-Anwendungen mit Docker bereitstellen (kostenlos)

Link: https://www.datacamp.com/tutorial/deploy-llm-applications-using-docker

Schritt-für-Schritt-Anleitung speziell für LLM-Apps mit RAG-Pipelines. Behandelt Dockerfile-Erstellung, Umgebungsverwaltung und Deployment.

4. Docker-Containerisierung für LLM-Apps (ApXML, kostenlos)

Link: https://apxml.com/courses/python-llm-workflows/chapter-10-deployment-operational-practices/containerization-docker-llm-apps

Behandelt Basis-Image-Auswahl, Abhängigkeitsverwaltung, Multi-Stage-Builds und Docker Compose für Multi-Service-LLM-Deployments.

Worauf du dich konzentrieren solltest: Schreiben eines Dockerfiles für eine Python/FastAPI-App, Verwenden von Multi-Stage-Builds, um Images klein zu halten, Docker Compose für Multi-Service-Setups (App + Datenbank + Redis), Umgebungsvariablen für Geheimnisse und .dockerignore, um das Durchsickern sensibler Dateien zu vermeiden.

Übungsprojekt: Containerisiere deine RAG-App aus Monat 3. Erstelle eine docker-compose.yml, die deine FastAPI-App, eine Vektordatenbank (Chroma oder Qdrant) und Redis für Caching startet. Stelle sie so bereit, dass docker compose up alles startet.

3. Hintergrundjobs und Warteschlangen

LLM-Aufrufe sind langsam. Wenn ein Benutzer deine App bittet, ein Dokument zu verarbeiten, und du ihn 30 Sekunden auf eine Antwort warten lässt, wird er gehen.

Hintergrundjobs ermöglichen es dir, die Anfrage sofort anzunehmen, sie asynchron zu verarbeiten und den Benutzer zu benachrichtigen, wenn sie fertig ist.

Ressourcen:

1. Celery Offizieller Erste-Schritte-Leitfaden (kostenlos)

Link: https://docs.celeryq.dev/en/stable/getting-started/introduction.html

Der Standard-Python-Task-Warteschlange. Behandelt grundlegende Einrichtung, Task-Definition und Worker-Verwaltung.

2. FastAPI-Hintergrundaufgaben-Dokumentation (offiziell, kostenlos)

Link: https://fastapi.tiangolo.com/tutorial/background-tasks/

Eingebaute, leichtgewichtige Hintergrundaufgaben für einfache Anwendungsfälle. Verwende dies für schnelle Fire-and-Forget-Aufgaben, Celery für alles Schwerere.

Worauf du dich konzentrieren solltest: Verstehen, wann du FastAPIs eingebaute BackgroundTasks vs. eine richtige Task-Warteschlange wie Celery verwenden solltest, Einrichten von Redis als Message Broker, Behandeln von Task-Fehlern und Wiederholungen und Zurückgeben des Job-Status an den Benutzer.

4. Authentifizierung und API-Key-Sicherheit

Wenn deine KI-App eine API hat, braucht sie Authentifizierung. Ohne sie kann jeder deine Endpunkte nutzen, deine LLM-Credits verbrennen, und du wachst mit einer Rechnung über 5.000 $ auf.

Ressourcen:

1. FastAPI-Sicherheitsdokumentation (offiziell, kostenlos)

Link: https://fastapi.tiangolo.com/tutorial/security/

Behandelt OAuth2, JWT-Tokens, API-Keys und dependency-basierte Auth-Muster. Die offizielle Referenz, arbeite das vollständige Tutorial durch.

2. OWASP API Security Top 10 (kostenlos)

Link: https://owasp.org/API-Security/

Die maßgebliche Liste von API-Sicherheitsrisiken. Verstehe Broken Authentication, Injection und Mass Assignment, bevor du etwas auslieferst.

3. Auth0: API-Auth-Best-Practices (kostenlos)

Link: https://auth0.com/docs/get-started/authentication-and-authorization

Praktischer Leitfaden zur Implementierung von Authentifizierung und Autorisierung in APIs.

Worauf du dich konzentrieren solltest: JWT-Tokens für Benutzer-Auth, API-Key-Verwaltung für Service-to-Service-Kommunikation, Ratenbegrenzung pro Benutzer/Key, niemals Geheimnisse im Code speichern (Umgebungsvariablen verwenden) und den Unterschied zwischen Authentifizierung (Wer bist du?) und Autorisierung (Was darfst du tun?) verstehen.

5. Logging und Observability

In der Produktion gilt: Wenn du nicht sehen kannst, was passiert, kannst du nicht beheben, was kaputt ist.

LLM-Apps haben eine besondere Herausforderung: Das Modell kann einen 200-Statuscode zurückgeben und trotzdem eine nutzlose oder halluzinierte Antwort produzieren. Traditionelles Monitoring fängt das nicht. Du brauchst LLM-spezifische Observability.

Ressourcen:

1. Langfuse (Open Source, kostenlose Stufe)

Link: https://langfuse.com/docs/observability/overview

Open-Source-LLM-Observability-Plattform. Verfolgt jede Anfrage: gesendeter Prompt, erhaltene Antwort, Token-Nutzung, Latenz, Tool-Aufrufe. Unterstützt Prompt-Versionierung, Evaluation und LLM-als-Richter-Bewertung. Integriert mit OpenAI, Anthropic, LangChain, LlamaIndex.

2. LangSmith (kostenlose Stufe)

Link: https://smith.langchain.com/

Vom LangChain-Team. Wenn du LangChain/LangGraph verwendest, ist die Einrichtung eine einzige Umgebungsvariable. Tracing, Debugging, Monitoring-Dashboards und Online-Evals. Die kostenlose Stufe ist großzügig für Entwicklung und kleinere Produktion.

3. Python Structlog (kostenlos)

Link: https://www.structlog.org/

Strukturiertes Logging für Python. Produziert JSON-Logs, die tatsächlich durchsuchbar und parsebar sind. Weitaus besser als print() oder einfaches Logging für Produktions-Apps.

Worauf du dich konzentrieren solltest: Tracing jedes LLM-Aufrufs (Eingabe-Prompt, Ausgabe, Tokens, Latenz, Kosten), strukturiertes Logging mit JSON-Ausgabe, Einrichten von Dashboards, die Anfragevolumen, Fehlerraten und Kosten pro Tag anzeigen, und Alarmierung, wenn etwas kaputtgeht oder die Kosten in die Höhe schießen.

6. Prompt- und Versionsverwaltung

In der Produktion sind deine Prompts Code. Sie brauchen Versionskontrolle, Tests und die Möglichkeit, Änderungen rückgängig zu machen.

Einen Prompt in der Produktion zu ändern, ohne zu verfolgen, was du geändert hast, ist der Weg, Dinge kaputt zu machen und nicht herauszufinden, warum.

Ressourcen:

1. Langfuse Prompt Management (kostenlos)

Link: https://langfuse.com/docs/prompts

Zentralisierte Prompt-Versionierung mit eingebautem Playground zum Testen. Versioniere deine Prompts getrennt von deinem Anwendungscode. Setze Prompt-Änderungen bereit, ohne deine App neu bereitzustellen.

2. Anthropic Best Practices für Prompt-Management (kostenlos)

Link: https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview

Best Practices für das Organisieren, Iterieren und Verwalten von Prompts in großem Maßstab.

Worauf du dich konzentrieren solltest: Speichern von Prompts außerhalb deines Anwendungscodes, Versionieren jeder Prompt-Änderung, A/B-Testen von Prompt-Varianten in der Produktion und eine Rollback-Strategie haben, wenn ein neuer Prompt schlechter abschneidet.

7. Kostenüberwachung und Ratenbegrenzung

LLM-APIs berechnen pro Token. Ohne Kostenkontrollen kann ein Traffic-Spike oder ein Bug in deinem Prompt innerhalb von Minuten Hunderte von Dollar verbrennen.

Ressourcen:

1. OpenAI Usage Dashboard (offiziell)

Link: https://platform.openai.com/usage

Verfolge Ausgaben nach Modell, nach Tag und setze Nutzungslimits.

2. Anthropic Usage Dashboard (offiziell)

Link: https://console.anthropic.com/Same – für Claude-API-Nutzung.

3. Helicone (kostenlose Stufe)

Link: https://www.helicone.ai/

Proxy-basierte Observability, die jeden LLM-Aufruf mit automatischer Kostenverfolgung erfasst. Eine Codezeile zur Einrichtung: Ändere einfach deine Basis-URL.

4. LiteLLM (Open Source, kostenlos)

Link: https://github.com/BerriAI/litellm

Vereinheitlichtes Interface für über 100 LLM-Anbieter. Beinhaltet Budgetverwaltung, Ratenbegrenzung und Kostenverfolgung über Anbieter hinweg.

Worauf du dich konzentrieren solltest: Harte Ausgabenlimits pro Tag/Monat setzen, benutzerspezifische Ratenbegrenzung in deiner API implementieren, günstigere Modelle für einfache Aufgaben verwenden (nicht für alles GPT-4/Opus nutzen), wiederholte identische Anfragen mit Redis cachen und die Kosten pro Anfrage überwachen, um teure Prompts frühzeitig zu erkennen.

8. Caching

Wenn 20 % deiner Benutzer ähnliche Fragen stellen, zahlst du 20 Mal für denselben LLM-Aufruf.

Caching ist der einfachste Weg, Kosten und Latenz gleichzeitig zu reduzieren.

Ressourcen:

1. Redis Offizielle Dokumentation (kostenlos)

Link: https://redis.io/docs/

Der Standard-In-Memory-Datenspeicher. Schnell, einfach und perfekt für das Caching von LLM-Antworten.

2. GPTCache (Open Source, kostenlos)

Link: https://github.com/zilliztech/GPTCache

Semantisches Caching, speziell für LLM-Anwendungen entwickelt. Nutzt Embedding-Ähnlichkeit, um zwischengespeicherte Antworten für semantisch ähnliche (nicht nur identische) Abfragen zu finden.

Worauf du dich konzentrieren solltest: Exakte Übereinstimmungs-Caching für identische Prompts, semantisches Caching für ähnliche Abfragen, Cache-Invalidierungsstrategien (TTL-basiert ist am einfachsten) und Messen der Cache-Trefferquote, um echte Kosteneinsparungen zu verstehen.

Meilenstein Monat 5

Am Ende dieses Monats solltest du in der Lage sein:

• Eine FastAPI + LLM-App in Docker mit korrekter Produktionskonfiguration bereitstellen.
• Langlaufende Aufgaben mit Hintergrundjobs und Warteschlangen handhaben.
• Deine API mit Authentifizierung, Ratenbegrenzung und API-Key-Verwaltung absichern.
• LLM-Aufrufe mit Langfuse oder LangSmith verfolgen und debuggen.
• Prompts mit Versionskontrolle und Rollback-Fähigkeit verwalten.
• Kosten in Echtzeit überwachen und Ausgabenlimits setzen.
• LLM-Antworten cachen, um Latenz und Kosten zu reduzieren.

⏩------------------------------------------------------------------------⏪

Monat 6: Spezialisieren und einstellbar werden

Diese Kenntnisse und Fähigkeiten, die du erworben hast, können in drei Richtungen angewendet werden (sicherlich nur die, die ich sehe).

Du musst eine davon auswählen und dich auf die Praxis konzentrieren.

Obwohl alles oben Genannte auch am besten rein durch Praxis gelernt wird.

Richtung 1: KI-Produktingenieur

Am besten, wenn du schnell Startup-Jobs willst.

Dies ist der häufigste Weg. Du baust KI-gestützte Produkte, mit denen echte Benutzer interagieren.

Du hast bereits die meisten Fähigkeiten aus den Monaten 1–5. Gehe jetzt tiefer auf die Produktseite.

Konzentriere dich auf:

• LLM-Apps
• RAG
• Agenten
• Deployment
• Produkt-UX

Was du diesen Monat lernen solltest:

1. End-to-End-Produktentwicklung

Hör auf, Tutorials zu bauen. Baue Produkte, die Menschen nutzen können.

Ressourcen:

1. Vercel AI SDK (kostenlos)

Link: https://sdk.vercel.ai/docs

Der schnellste Weg, KI-gestützte Benutzeroberflächen mit Streaming-Unterstützung zu bauen. React-, Next.js- und Vue-Integrationen mit integrierten Streaming-UI-Komponenten.

2. Streamlit (kostenlos)

Link: https://docs.streamlit.io/

Baue Daten-Apps und KI-Demos in reinem Python. Ideal für interne Tools und MVPs, nicht für produktionsreife UIs.

3. Gradio (kostenlos)

Link: https://www.gradio.app/docsQuick ML/AI-Schnittstellen mit minimalem Code. Besonders geeignet zum Vorzeigen von Modellen und zum Erstellen von Prototypen

Worauf du dich konzentrieren solltest: Baue diesen Monat 2–3 komplette Projekte, die du vorzeigen kannst. Eine „Chat mit deinen Dokumenten“-App, ein KI-gestütztes internes Tool oder einen Agenten, der einen echten Arbeitsablauf automatisiert. Veröffentliche sie. Stelle sie auf GitHub. Setze sie irgendwo ein, wo Leute sie ausprobieren können.

2. Produkt-UX für KI

KI-Produkte scheitern, wenn die UX die Einschränkungen des Modells nicht berücksichtigt.

Ressourcen:

1. Google: People + AI Guidebook (kostenlos)

Link: https://pair.withgoogle.com/guidebook/

Die beste Ressource zur Gestaltung der Mensch-KI-Interaktion. Deckt das Setzen von Erwartungen, den Umgang mit Fehlern und den Aufbau von Vertrauen ab.

2. Nielsen Norman Group: AI UX Guidelines (kostenlos)

Link: https://www.nngroup.com/topic/artificial-intelligence/

Forschungsgestützte Richtlinien für KI-Schnittstellen.

Worauf du dich konzentrieren solltest: Wie man Ladezustände mit Streaming handhabt, was man anzeigt, wenn das Modell falsch liegt, wie man Benutzern Feedback ermöglicht und wie man dafür gestaltet, dass KI-Ausgabe probabilistisch ist – sie wird manchmal falsch sein.

Richtung 2: Angewandter ML / LLM Engineer

Am besten, wenn du tiefere technische Rollen anstrebst.

Diese Richtung ist für Ingenieure, die über API-Aufrufe hinausgehen und verstehen wollen, was unter der Haube passiert.

Fokus auf:

• Fine-Tuning
• Wann Fine-Tuning vs. Prompt
• Evaluierung
• Inferenzoptimierung
• Open-Source-Modelle
• Trainingspipelines

Was du diesen Monat lernen solltest:

1. Wann Fine-Tuning vs. Prompt Engineering

Die wichtigste Entscheidung im angewandten ML: Musst du das Modell ändern oder nur die Art, wie du mit ihm sprichst?

Ressourcen:

1. Google ML Crash Course: Fine-tuning, Distillation, and Prompt Engineering (kostenlos)

Link: https://developers.google.com/machine-learning/crash-course/llm/tuning

Die klarste Erklärung der drei Ansätze und wann man sie verwendet.

2. Codecademy: Prompt Engineering vs Fine-Tuning (kostenlos)

Link: https://www.codecademy.com/article/prompt-engineering-vs-fine-tuning

Praktischer Entscheidungsrahmen mit klaren Anwendungsfällen für jeden Ansatz.

3. IBM: RAG vs Fine-Tuning vs Prompt Engineering (kostenlos)

Link: https://www.ibm.com/think/topics/rag-vs-fine-tuning-vs-prompt-engineering

Deckt den gesamten Entscheidungsraum ab, einschließlich der Frage, wann man Ansätze kombiniert.

Entscheidungsrahmen zum Merken: Beginne mit Prompt Engineering (günstigste, schnellste). Füge RAG hinzu, wenn das Modell Zugriff auf spezifische Daten benötigt. Fine-Tune nur, wenn Prompting + RAG nicht die erforderliche Qualität, Konsistenz oder Latenz erreichen können.

2. Fine-Tuning in der Praxis

Wenn du doch Fine-Tuning benötigst, hier ist, wie es geht.

Ressourcen:

1. OpenAI Fine-tuning Guide (offiziell, kostenlos)

Link: https://platform.openai.com/docs/guides/fine-tuning

Der einfachste Weg, mit Fine-Tuning zu beginnen. Lade einen JSONL-Datensatz hoch, führe einen Job aus, erhalte ein benutzerdefiniertes Modell. Gut zum Erlernen des Arbeitsablaufs, auch wenn du später zu Open-Source-Modellen wechselst.

2. HuggingFace Transformers Fine-tuning Tutorial (kostenlos)

Link: https://huggingface.co/docs/transformers/training

Die Standardbibliothek für die Arbeit mit Open-Source-Modellen. Deckt Training, Evaluierung und Modellspeicherung ab.

3. Unsloth (Open Source, kostenlos)

Link: https://github.com/unslothai/unsloth

2× schnelleres Fine-Tuning mit 80 % weniger Speicher. Unterstützt LoRA und QLoRA direkt. Der schnellste Weg zum Fine-Tuning von Open-Source-Modellen auf Consumer-Hardware.

4. LLaMA-Factory (Open Source, kostenlos)

Link: https://github.com/hiyouga/LLaMA-Factory

Einheitliches Framework für das Fine-Tuning von 100+ LLMs. Enthält eine Web-UI für No-Code-Fine-Tuning. Unterstützt LoRA, QLoRA, vollständiges Fine-Tuning, RLHF und DPO.

Worauf du dich konzentrieren solltest: Vorbereitung von Trainingsdatensätzen (JSONL-Format), Verständnis von LoRA und QLoRA (parametereffizientes Fine-Tuning), Ausführen eines Fine-Tuning-Jobs auf OpenAI oder mit HuggingFace, Evaluierung des feinabgestimmten Modells im Vergleich zum Basismodell und Wissen, wann sich Fine-Tuning nicht lohnt.

3. Open-Source-Modelle

Nicht alles muss über OpenAI oder Anthropic laufen. Open-Source-Modelle geben dir volle Kontrolle, keine API-Kosten und die Möglichkeit, lokal zu laufen.

Ressourcen:

1. Ollama (kostenlos)

Link: https://ollama.ai/

Führe Open-Source-LLMs lokal mit einem Befehl aus. Unterstützt Llama, Mistral, Gemma und Dutzende anderer. Der schnellste Weg, mit Open-Source-Modellen zu experimentieren.

2. HuggingFace Model Hub (kostenlos)

Link: https://huggingface.co/models

Das größte Repository für Open-Source-Modelle. Durchstöbere, lade herunter und setze Modelle für jede Aufgabe ein.

3. vLLM (Open Source, kostenlos)

Link: https://github.com/vllm-project/vllm

High-Throughput-LLM-Inferenz-Engine. 2–4× schneller als naives HuggingFace-Serving. Der Standard für das Produktions-Serving von Open-Source-Modellen.

Worauf du dich konzentrieren solltest: Modelle lokal mit Ollama zum Testen ausführen, Quantisierung verstehen (GGUF, GPTQ, AWQ) und warum sie für die Bereitstellung wichtig ist, Open-Source-Modelle gegen API-Modelle für deinen Anwendungsfall benchmarken und Modelle in Produktion mit vLLM bereitstellen.

4. Inferenzoptimierung

Modelle in der Produktion schneller und günstiger laufen lassen.

Ressourcen:

1. HuggingFace: Optimizing LLM Inference (kostenlos)

Link: https://huggingface.co/docs/transformers/llm_optims

Deckt KV-Cache-Optimierung, Quantisierung und Batch-Strategien ab.

2. NVIDIA TensorRT-LLM (kostenlos)

Link: https://github.com/NVIDIA/TensorRT-LLM

Maximale Inferenzleistung auf NVIDIA-GPUs. Wird von den meisten Produktions-LLM-Servings in großem Maßstab verwendet.

Worauf du dich konzentrieren solltest: Batch-Strategien für Durchsatz, Quantisierung zur Reduzierung von Speicher und Kosten, KV-Cache-Optimierung für schnellere Generierung und Wahl der richtigen Hardware für deine Inferenz-Workload.

Richtung 3: AI Automation Engineer

Am besten, wenn du sofort für Unternehmen bauen möchtest.

Diese Richtung dreht sich um die Automatisierung echter Geschäftsabläufe mit KI. Weniger um Produktentwicklung, mehr um die Lösung operativer Probleme.

Fokus auf:

• Workflow-Orchestrierung
• Geschäftsprozessautomatisierung
• Multi-Tool-Systeme
• CRM, Dokumente, E-Mail, Support, Betriebs-Anwendungsfälle

Was du diesen Monat lernen solltest:

1. Workflow-Orchestrierung

Echte Geschäftsautomatisierung ist fast nie ein einzelner LLM-Aufruf. Es sind Aktionsketten über mehrere Systeme hinweg.

Ressourcen:

1. n8n (Open Source, kostenlos zum Selbsthosten)

Link: https://docs.n8n.io/

Visuelle Workflow-Automatisierung mit KI-Knoten. Verbinde LLMs mit über 400 Integrationen (Slack, Gmail, Notion, CRMs usw.). Die beste No-Code/Low-Code-Option für KI-Automatisierung.

2. LangGraph: Multi-Agent Workflows (kostenlos)

Link: https://langchain-ai.github.io/langgraph/concepts/multi_agent/

Code-first Orchestrierung für komplexe Multi-Agent-Systeme. Wenn n8n nicht ausreicht und du vollständige programmatische Kontrolle benötigst.

3. Temporal (Open Source, kostenlos)

Link: https://docs.temporal.io/

Durable Workflow Engine für langlebige, fehlertolerante Prozesse. Wenn deine Automatisierung Abstürze, Wiederholungen und Timeouts überstehen muss.

Worauf du dich konzentrieren solltest: Entwerfen von Workflows, die Fehler elegant behandeln, Verbinden von KI mit echten Geschäftstools (E-Mail, CRM, Datenbanken, Tabellenkalkulationen), Erstellen von Human-in-the-Loop-Genehmigungsschritten und Protokollieren jeder automatisierten Aktion für Audit-Trails.

2. Geschäftsprozessautomatisierung

Das Geld in der KI-Automatisierung liegt in der Lösung spezifischer, teurer Geschäftsprobleme.

Ressourcen:

1. Zapier AI Actions (kostenlose Stufe)

Link: https://zapier.com/ai

Verbinde KI mit über 6.000 Apps ohne Code. Gut zum Prototyping von Automatisierungen, bevor du benutzerdefinierte Lösungen baust.

2. Make (Integromat) (kostenlose Stufe)

Link: https://www.make.com/

Visuelle Automatisierungsplattform mit erweiterter Logik und KI-Integrationen. Leistungsfähiger als Zapier für komplexe Workflows.

Worauf du dich konzentrieren solltest: Identifizieren der Automationsziele mit dem höchsten ROI (normalerweise Aufgaben, die repetitiv, zeitaufwendig und regelbasiert sind), Bauen von Automatisierungen, die Menschen ergänzen statt ersetzen, und Messen der tatsächlich gesparten Zeit und des Geldes.

3. CRM, Dokumente, E-Mail, Support-Automation

Die häufigsten und wertvollsten KI-Automatisierungsanwendungsfälle.

Ressourcen:

1. OpenAI Cookbook: AI-Powered Email Processing (kostenlos)

Link: https://github.com/openai/openai-cookbook

Muster zum Klassifizieren, Weiterleiten und Beantworten von E-Mails mit KI.

2. LangChain: Document Processing Pipelines (kostenlos)

Link: https://python.langchain.com/docs/how_to/#document-loaders

Aufnehmen und Verarbeiten von Dokumenten aus über 80 Quellen.

Worauf du dich konzentrieren solltest: Bauen eines KI-gestützten E-Mail-Klassifikators und automatischen Antworters, Erstellen einer Dokumentenverarbeitungspipeline, die strukturierte Daten extrahiert, Bauen eines Support-Chatbots, der RAG über deine Wissensdatenbank verwendet, und Integration von KI in bestehende CRM-Workflows (HubSpot, Salesforce usw.).

Übungsprojekt für Richtung 3: Baue ein End-to-End-Lead-Qualifizierungssystem. Es sollte:

Leads aus einer Quelle scrapen oder importieren (CSV, API oder Formular)

Ein LLM verwenden, um jeden Lead zu recherchieren (Unternehmensinfo, Eignungsbewertung)

Leads basierend auf deinem ICP bewerten und einstufen

Personalisierte Kontaktnachrichten entwerfen

Alles in einer Tabelle oder CRM protokollieren

Dies ist eine echte, verkaufbare Automatisierung, für die Unternehmen tatsächlich bezahlen.

⏩------------------------------------------------------------------------⏪

FAZIT

Was du nach diesen 6 Monaten erwarten kannst???

Ich werde ehrlich zu dir sein, ohne Geldberge zu versprechen.

Dieser Fahrplan wird dich nicht in 6 Monaten zu einem Senior AI Engineer machen.

Aber es wird dich zu jemandem machen, der echte KI-Systeme bauen, ausliefern und bereitstellen kann, die echte Probleme lösen.

Und genau das ist es, wofür der Markt derzeit bezahlt.

Die Nachfrage nach KI-Ingenieuren lässt nicht nach. Die Stellenausschreibungen sind im Jahresvergleich um 25 % gestiegen.

PwC fand einen Lohnaufschlag von 56 % für Rollen, die KI-Kenntnisse erfordern, im Vergleich zu denselben Rollen ohne.

Nur 1 % der Unternehmen gelten als „KI-reif“, was bedeutet, dass 99 % noch Hilfe brauchen. Das US Bureau of Labor Statistics prognostiziert ein Beschäftigungswachstum von 26 % bis 2034.

Das sind keine Hype-Zahlen. Das sind die echten Zahlen basierend auf Analysen (von Claude kek entnommen).

Wenn du in den USA Vollzeit arbeitest:

Junior AI Engineers starten bei 90.000–130.000 $

Mid-Level (3–5 Jahre) liegen bei 155.000–200.000 $

Senior-Rollen gehen von 195.000–350.000 $+

Laut Glassdoor (März 2026) liegt der Durchschnitt bei 184.757 $

Das Mid-Level-Band wächst am schnellsten mit 9,2 % im Jahresvergleich, weil Unternehmen dringend Leute brauchen, die Produktions-KI ohne ständige Aufsicht ausliefern können.

Wenn du eher freiberuflich arbeiten möchtest:

AI Agent Development geht für 175–300 $/Stunde

RAG-Implementierung 150–250 $/Stunde

LLM-Integration 125–200 $/Stunde

Ein Entwickler auf Reddit baute in zwei Wochen ein Dokumentenzusammenfassungstool für eine Anwaltskanzlei und verdiente 8.000 $. Ein Freiberufler, der 25 Stunden/Woche zu 150 $/Stunde abrechnet, kommt auf 195.000 $/Jahr.

Und wenn du den Consulting-Weg gehst, über den ich in meinem früheren Beitrag gesprochen habe, kannst du verlangen:

300–5.000 $ für die Einrichtung eines KI-Agenten für ein Unternehmen

500–2.000 $/Monat für KI-Content-Management

1.000–4.000 $ zur Automatisierung des Kundensupports

500–2.000 $ für die Einrichtung von Cold Outreach

Das Servicespektrum ist noch breiter, aber sobald du die Fähigkeiten aus diesem Fahrplan beherrschst, bist du bereits ein gefragter Spezialist im Jahr 2026.

Das sind echte Zahlen von echten Menschen, die echte Arbeit leisten.

Und hier ist, was ich eigentlich möchte, dass du aus all dem mitnimmst:

Wähle ein Projekt pro Monat aus und baue es. Nicht darüber lesen. Kein Tutorial anschauen. Baue es, zerstöre es, repariere es, setze es ein, stelle es auf GitHub. Die Ingenieure, die eingestellt werden, sind diejenigen, die zeigen, was sie gebaut haben, nicht was sie studiert haben.

Beginne zu teilen, was du lernst. Schreibe darüber auf X, LinkedIn, überall. Lehren ist der schnellste Weg zu lernen und baut gleichzeitig deinen Ruf auf. Die besten Gelegenheiten, die ich gesehen habe, kamen von Leuten, die sichtbar waren, nicht von Leuten, die sich auf 500 Stellenanzeigen beworben haben.

Und bitte warte nicht, bis du dich bereit fühlst. Du wirst dich nie bereit fühlen. Die Lücke zwischen „Ich lerne“ und „Ich baue“ ist der Ort, an dem die meisten Menschen für immer stecken bleiben.

Beginne dich zu bewerben, beginne freiberuflich zu arbeiten, beginne Dienstleistungen anzubieten, sobald du funktionierende Projekte hast. Auch wenn sie nicht perfekt sind. Der Markt belohnt keine Perfektion. Er belohnt Menschen, die ausliefern können.

6 Monate reichen aus, um alles zu verändern, wenn du wirklich die Arbeit reinsteckst.

Und ich glaube wirklich, dass jeder von euch, der dies liest, es schaffen kann.

Höre einfach nie auf zu bauen und nie auf zu lernen.

Hoffe, das war nützlich für dich, meine Familie ❤️